public void Configure(
IApplicationBuilder app,
IHostingEnvironment env,
LifetimeManager lifetimeManager,
InterpreterManager interpreterManager,
SecurityManager securityManager
) {
lifetimeManager.Initialize();
interpreterManager.Initialize();
app.UseWebSockets(new WebSocketOptions {
ReplaceFeature = true,
KeepAliveInterval = TimeSpan.FromMilliseconds(1000000000),
ReceiveBufferSize = 0x10000
});
var routeBuilder = new RouteBuilder(app, new RouteHandler(RemoteUriHelper.HandlerAsync));
routeBuilder.MapRoute("help_and_shiny", "remoteuri");
app.UseRouter(routeBuilder.Build());
app.UseBasicAuthentication(options => {
options.Events = new BasicEvents { OnSignIn = securityManager.SignInAsync };
});
app.Use((context, next) => {
if (!context.User.Identity.IsAuthenticated) {
return context.Authentication.ChallengeAsync();
} else {
return next();
}
});
app.UseMvc();
}
//<inheritdoc />
public RequestDelegate CreatePipeline()
{
_logger.LogTrace("Creating new ApplicationBuilder.");
IApplicationBuilder app = new ApplicationBuilder(_serviceProvider);
app.Properties["host.AppName"] = _tenant.TenantId;
_logger.LogTrace("Registering middlewares.");
foreach (var middlewareProvider in _middlewareProviders)
{
middlewareProvider.Configure(app);
}
var routeBuilder = new RouteBuilder(app) { DefaultHandler = new MvcRouteHandler() };
_logger.LogDebug("Registering route providers.");
foreach (var routeProvider in _routeProviders.OrderBy(t => t.RouterPriority))
{
routeProvider.ConfigureRoutes(routeBuilder);
}
_logger.LogTrace("Building tenant router.");
app.UseRouter(routeBuilder.Build());
app.Run(async context =>
{
await context.Response.WriteAsync("You in tenant pipeline! " + _tenant.TenantId);
});
_logger.LogTrace("Building pipeline");
var pipeline = app.Build();
return pipeline;
}
/// <summary>
/// Adds MVC to the <see cref="IApplicationBuilder"/> request execution pipeline.
/// </summary>
/// <param name="app">The <see cref="IApplicationBuilder"/>.</param>
/// <param name="configureRoutes">A callback to configure MVC routes.</param>
/// <returns>A reference to this instance after the operation has completed.</returns>
public static IApplicationBuilder UseMvc(
this IApplicationBuilder app,
Action<IRouteBuilder> configureRoutes)
{
if (app == null)
{
throw new ArgumentNullException(nameof(app));
}
if (configureRoutes == null)
{
throw new ArgumentNullException(nameof(configureRoutes));
}
// Verify if AddMvc was done before calling UseMvc
// We use the MvcMarkerService to make sure if all the services were added.
if (app.ApplicationServices.GetService(typeof(MvcMarkerService)) == null)
{
throw new InvalidOperationException(Resources.FormatUnableToFindServices(
nameof(IServiceCollection),
"AddMvc",
"ConfigureServices(...)"));
}
var routes = new RouteBuilder(app)
{
DefaultHandler = app.ApplicationServices.GetRequiredService<MvcRouteHandler>(),
};
configureRoutes(routes);
routes.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute(app.ApplicationServices));
return app.UseRouter(routes.Build());
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logFactory)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseStatusCodePages(subApp =>
{
subApp.Run(async context =>
{
context.Response.ContentType = "text/html";
await context.Response.WriteAsync($"Error @ {context.Response.StatusCode}");
});
});
}
logFactory.AddConsole(LogLevel.Trace);
logFactory.AddSerilog();
var logger = logFactory.CreateLogger <Startup>();
logger.LogTrace("Trace msg");
logger.LogDebug("Debug msg");
logger.LogInformation("Info msg");
logger.LogWarning("Warn msg");
logger.LogError("Error msg");
logger.LogCritical("Critical msg");
app.UseMiddleware <RequestIdMiddleware>();
//app.Run(ctx =>
//{
// //throw new Exception("some error");
// //ctx.Response.StatusCode = 500;
// return Task.FromResult(0);
//});
//app.UseIISPlatformHandler();
//app.UseFileServer();
var router = new RouteBuilder(app)
.MapGet("", async ctx => await ctx.Response.WriteAsync("Hello from routing"))
.MapGet("sub", async ctx => await ctx.Response.WriteAsync("Hello from sub"))
.MapGet("item/{id:int}", ctx => ctx.Response.WriteAsync($"Item ID: {ctx.GetRouteValue("id")}"))
;
app.UseRouter(router.Build());
app.UseMvc();
//app.UseRequestCulture();
//app.Run(async ctx => await ctx.Response.WriteAsync($"Hello {CultureInfo.CurrentCulture.DisplayName}"));
//app.Run(async ctx => await ctx.Response.WriteAsync($"{Configuration["greeting"]}"));
}
public IRouteBuilder Build()
{
IApplicationBuilder appBuilder = new ApplicationBuilder(_serviceProvider);
var routeBuilder = new RouteBuilder(appBuilder)
{
};
return(routeBuilder);
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ServerlessProject serverlessProject)
{
var routeBuilder = new RouteBuilder(app);
routeBuilder.AddRoutes <T>(serverlessProject);
var routes = routeBuilder.Build();
app.UseRouter(routes);
}
private static IRouter GenerateRouter(IApplicationBuilder applicationBuilder)
{
var routes = new RouteBuilder(applicationBuilder)
{
DefaultHandler = applicationBuilder.ApplicationServices.GetRequiredService <MvcRouteHandler>()
};
routes.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute(applicationBuilder.ApplicationServices));
return(routes.Build());
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
app.UseFileServer();
app.UseSignalR(options => options.MapHub <Broadcaster>("broadcast"));
var routeBuilder = new RouteBuilder(app);
routeBuilder.MapGet("generatetoken", c => c.Response.WriteAsync(GenerateToken(c)));
app.UseRouter(routeBuilder.Build());
}
protected override void ConfigureImpl_AfterHelper(HttpServerStartupConfig cfg, IApplicationBuilder app, IWebHostEnvironment env, IHostApplicationLifetime lifetime)
{
RouteBuilder rb = new RouteBuilder(app);
Handler.InsertActionListReqAuthToRouteBuilder(rb);
IRouter router = rb.Build();
app.UseRouter(router);
}
public IRouter BuildRouter(IApplicationBuilder appBuilder)
{
RouteBuilder builder = new RouteBuilder(appBuilder);
builder.MapMiddlewarePost("/api/activities", (appBuilder) =>
{
appBuilder.UseMiddleware <ApiAuthenticationMiddleware>();
});
return(builder.Build());
}
public void should_return_simple_json_aggregator()
{
var route = new RouteBuilder()
.Build();
this.Given(_ => GivenRoute(route))
.When(_ => WhenIGet())
.Then(_ => ThenTheAggregatorIs <SimpleJsonResponseAggregator>())
.BDDfy();
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceRouteBuilder"/> class.
/// </summary>
/// <param name="routes">The routes builder.</param>
public ServiceRouteBuilder(RouteBuilder routes)
{
_routes = routes;
_serviceProvider = _routes.ServiceProvider;
_negotiateHandler = _serviceProvider.GetRequiredService <NegotiateHandler>();
var loggerFactory = _serviceProvider.GetService <ILoggerFactory>() ?? NullLoggerFactory.Instance;
_logger = loggerFactory.CreateLogger <ServiceRouteBuilder>();
}
private static RouteEntry CreateRouteEntry(string routeTemplate)
{
var route = new RouteBuilder().BuildDirectRoute(routeTemplate, new[] { "GET" }, "Controller", "Action", null, null);
return new RouteEntry()
{
Route = route,
Template = routeTemplate,
ParsedRoute = RouteParser.Parse(route.Url)
};
}
public void AddWafApiRoutes(IApplicationBuilder applicationBuilder)
{
PrepareWafActions();
var routeHandler = new RouteHandler(ProcessWafActionRequestAsync);
var routeBuilder = new RouteBuilder(applicationBuilder, routeHandler);
routeBuilder.MapRoute("waf", WafConstants.WafRouteTemplatePath);
applicationBuilder.UseRouter(routeBuilder.Build());
}
public void Initialize(RouteBuilder routeBuilder)
{
routeBuilder.DefaultHandler = new RouteHandler(Handle);
foreach (var controller in Assembly.GetExecutingAssembly().GetTypes()
.Where(type =>
type.GetCustomAttribute <ControllerAttribute>() != null && type.IsSubclassOf(typeof(Controller))))
{
var controllerAttribute = controller.GetCustomAttribute <ControllerAttribute>();
var controllerPath = !string.IsNullOrEmpty(controllerAttribute.ControllerName) ?
$"{controllerAttribute.ControllerName}{(controllerAttribute.ControllerName[^1] == '/' ? "" : "/")}" : "";
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
var trackPackageRouteHandler = new RouteHandler(async context =>
{
var routeValues = context.GetRouteData().Values;
await context.Response.WriteAsync($"Hello! Route values: {string.Join(", ", routeValues)}");
});
var routeBuilder = new RouteBuilder(app, trackPackageRouteHandler);
routeBuilder.MapRoute("Track package route", "{package?}/{operation:regex(^track|create|detonate$)=create}/{id:int:range(1,5)}/{*anything}");
routeBuilder.MapGet("hello/{name}", context =>
{
var name = context.GetRouteValue("name");
return(context.Response.WriteAsync($"Hi, {name}"));
});
var routes = routeBuilder.Build();
app.UseRouter(routes);
app.Run(async context =>
{
var dictionary = new RouteValueDictionary()
{
{ "operation", "create" }, { "id", 3 }, { "package", "123" }
};
var vpc = new VirtualPathContext(context, null, dictionary, "Track package route");
var path = routes.GetVirtualPath(vpc).VirtualPath;
context.Response.ContentType = "text/html";
await context.Response.WriteAsync("Menu<hr/>");
await context.Response.WriteAsync($"<a href=\"{path}\">Create Package 123</a><br/>");
});
//loggerFactory.AddConsole(Configuration.GetSection("Logging"));
//loggerFactory.AddDebug();
//if (env.IsDevelopment())
//{
// app.UseDeveloperExceptionPage();
// app.UseBrowserLink();
//}
//else
//{
// app.UseExceptionHandler("/Home/Error");
//}
//app.UseStaticFiles();
//app.UseMvc(routes =>
//{
// routes.MapRoute(
// name: "default",
// template: "{controller=Home}/{action=Index}/{id?}");
//});
}
public static void UseSecurity(this IApplicationBuilder app, IHostingEnvironment env, PathString pathBase)
{
if (!env.IsDevelopment())
{
app.UseAuthentication();
app.Use(async(httpContext, next) =>
{
try
{
var authenticated = httpContext.User?.Identity?.IsAuthenticated ?? false;
if (!authenticated)
{
await httpContext.ChallengeAsync(OpenIdConnectDefaults.AuthenticationScheme, new AuthenticationProperties
{
RedirectUri = pathBase + "/"
});
}
else
{
// This is a workaround till Dolittle has moved over to the new approach for resolving principals
SecurityBindings.CurrentClaimsPrincipal.Value = httpContext.User;
await next();
}
}
catch (Exception ex)
{
Console.WriteLine("Exception : " + ex.Message + " - " + ex.StackTrace);
}
});
}
var routeBuilder = new RouteBuilder(app);
var basePath = string.Empty;
basePath = pathBase.Value.TrimStart('/');
if (!basePath.EndsWith('/'))
{
basePath = basePath + '/';
}
routeBuilder.MapGet($"{basePath}signout", async(httpContext) =>
{
await httpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
await httpContext.SignOutAsync(OpenIdConnectDefaults.AuthenticationScheme);
});
routeBuilder.MapGet($"{basePath}identity", async(httpContext) =>
{
var user = httpContext.User?.Identity?.Name ?? "[Not Logged In]";
await httpContext.Response.WriteAsync(user);
});
var router = routeBuilder.Build();
app.UseRouter(router);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
//app.UseHttpsRedirection();
app.UseDefaultFiles();
app.UseStaticFiles();
app.UseCookiePolicy();
app.UseSignalR(r =>
{
r.MapHub <IntegrationTestHub>("/IntegrationTestHub");
});
app.UseMvc();
var trackPackageRouteHandler = new RouteHandler(context =>
{
var routeValues = context.GetRouteData().Values;
return(context.Response.WriteAsync($"Hello! Route values: {string.Join(", ", routeValues)}"));
});
var routeBuilder = new RouteBuilder(app, trackPackageRouteHandler);
routeBuilder.MapRoute(
"Track Package Route",
"package/{operation:regex(^track|create|detonate$)}/{id:int}");
routeBuilder.MapGet("channels/{id}", context =>
{
var id = context.GetRouteValue("id") as string;
var result = God.Channels.TryGetValue(id, out var channels);
if (result)
{
return(context.Response.WriteAsync(JsonConvert.SerializeObject(result)));
}
context.Response.StatusCode = 404;
return(context.Response.WriteAsync(string.Empty));
});
var routes = routeBuilder.Build();
app.UseRouter(routes);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
//var trackPackageRouteHandler = new RouteHandler(context =>
//{
// var routeValues = context.GetRouteData().Values;
// return context.Response.WriteAsync(
// $"Hello! Route values: {string.Join(", ", routeValues)}");
//});
var trackPackageRouteHandler = new RouteHandler(context =>
{
return(context.Response.WriteAsync(
"Hello! 404 "));
});
var routeBuilder = new RouteBuilder(app, trackPackageRouteHandler);
//routeBuilder.MapRoute(
// "Track Package Route",
// "Home/{operation:regex(^track|Index|detonate$)}/{id:int}");
// when regex(^track|Index|detonate$) is true,return "Hello! 404. such as http://localhost:3980/Home/Index; Otherwise, the following 'default' route is executed",such as http://localhost:3980/Home/About
routeBuilder.MapRoute(
"Ignore Route",
"Home/{operation:regex(^track|Index|detonate$)}/{id?}");
//routeBuilder.MapGet("hello/{name}", context =>
//{
// var name = context.GetRouteValue("name");
// // This is the route handler when HTTP GET "hello/<anything>" matches
// // To match HTTP GET "hello/<anything>/<anything>,
// // use routeBuilder.MapGet("hello/{*name}"
// return context.Response.WriteAsync($"Hi, {name}!");
//});
var routess = routeBuilder.Build();
app.UseRouter(routess);
//app.UseMiddleware<IgnoreClientRoutes>(new List<string>() { "track", "Index", "detonate" });
// app.UseMvc(routes =>
// {
// routes.MapRoute(
//"Track Package Route",
//"Home/{operation:regex(^track|Create|detonate$)}");
// //return context.Response.WriteAsync($"Hi, !");
// });
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=About}/{id?}");
});
}
public static void Init(RouteBuilder routeBuilder)
{
var RP = new Yahoo_RP(
Config.config.rpPrincipal,
"https://open.login.yahooapis.com/openid/op/auth",
Config.config.agentRootUrl + "callback/Yahoo",
Config.config.stateSecretKey);
routeBuilder.MapRoute("login/Yahoo", RP.Login_StartAsync);
routeBuilder.MapRoute("callback/Yahoo", RP.Login_CallbackAsync);
}
public RouteChain(MethodCall action, Route route)
{
Action = action;
Route = route;
TypeName = $"{Action.HandlerType.FullNameInCode().Replace(".", "_")}_{action.Method.Name}_{action.Method.GetParameters().Select(x => x.Name).Join("_")}";
InputType = RouteBuilder.DetermineInputType(action.Method);
ResourceType = action.ReturnVariable?.VariableType;
Route.Chain = this;
}
private static RouteEntry CreateRouteEntry(string routeTemplate)
{
var route = new RouteBuilder().BuildDirectRoute(routeTemplate, new[] { "GET" }, "Controller", "Action", null, null);
return(new RouteEntry()
{
Route = route,
RouteTemplate = routeTemplate,
ParsedRoute = RouteParser.Parse(route.Url)
});
}
public static IQueryable ApplyTo <TEntity>(this HttpRequest request, IQueryable <TEntity> query)
where TEntity : class
{
// Parte 1 - Se registran los componentes requeridos por la implementación de
// Microsoft ASP.NET Core OData y se memorizan en una variable estática
if (_provider == null)
{
var collection = new ServiceCollection();
collection.AddMvcCore(options =>
{
options.EnableEndpointRouting = false;
}).SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
collection.AddOData();
collection.AddTransient <ODataUriResolver>();
collection.AddTransient <ODataQueryValidator>();
collection.AddTransient <TopQueryValidator>();
collection.AddTransient <FilterQueryValidator>();
collection.AddTransient <SkipQueryValidator>();
collection.AddTransient <OrderByQueryValidator>();
_provider = collection.BuildServiceProvider();
}
// Parte 2 - Se configura la ruta de ASP.NET Core OData
if (_routeBuilder == null)
{
_routeBuilder = new RouteBuilder(new ApplicationBuilder(_provider));
_routeBuilder.EnableDependencyInjection();
}
// Parte 3 - Se simula un pedido HTTP como si viniese desde ASP.NET Core
var modelBuilder = new ODataConventionModelBuilder(_provider);
modelBuilder.AddEntityType(typeof(TEntity));
var edmModel = modelBuilder.GetEdmModel();
var httpContext = new DefaultHttpContext
{
RequestServices = _provider
};
HttpRequest req = new DefaultHttpRequest(httpContext)
{
Method = "GET",
Host = request.Host,
Path = request.Path,
QueryString = request.QueryString
};
var oDataQueryContext = new ODataQueryContext(edmModel, typeof(TEntity), new Microsoft.AspNet.OData.Routing.ODataPath());
var odataQuery = new ODataQueryOptions <TEntity>(oDataQueryContext, req);
// Parte 4 - Se aplica la consulta OData al queryable que nos pasan por parámetro
return(odataQuery.ApplyTo(query.AsQueryable()));
}
public IRouteBuilder Build()
{
IApplicationBuilder appBuilder = new ApplicationBuilder(_serviceProvider);
var routeBuilder = new RouteBuilder(appBuilder)
{
DefaultHandler = _serviceProvider.GetRequiredService <MvcRouteHandler>()
};
return(routeBuilder);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
var routeBuilder = new RouteBuilder(app);
routeBuilder.MapGet("api/values/{id}", context => {
return(context.Response.WriteAsync("value"));
});
var routes = routeBuilder.Build();
app.UseRouter(routes);
}
public void should_return_user_defined_aggregator()
{
var route = new RouteBuilder()
.WithAggregator("doesntmatter")
.Build();
this.Given(_ => GivenRoute(route))
.When(_ => WhenIGet())
.Then(_ => ThenTheAggregatorIs <UserDefinedResponseAggregator>())
.BDDfy();
}
// Build the middleware pipeline for the current tenant
public RequestDelegate BuildTenantPipeline(ShellSettings shellSettings, IServiceProvider serviceProvider)
{
var startups = serviceProvider.GetServices <IStartup>();
var inlineConstraintResolver = serviceProvider.GetService <IInlineConstraintResolver>();
IApplicationBuilder appBuilder = new ApplicationBuilder(serviceProvider);
string routePrefix = "";
if (!string.IsNullOrWhiteSpace(shellSettings.RequestUrlPrefix))
{
routePrefix = shellSettings.RequestUrlPrefix + "/";
}
var routeBuilder = new RouteBuilder(appBuilder)
{
DefaultHandler = serviceProvider.GetRequiredService <MvcRouteHandler>()
};
var prefixedRouteBuilder = new PrefixedRouteBuilder(routePrefix, routeBuilder, inlineConstraintResolver);
// Register one top level TenantRoute per tenant. Each instance contains all the routes
// for this tenant.
// In the case of several tenants, they will all be checked by ShellSettings. To optimize
// the TenantRoute resolution we can create a single Router type that would index the
// TenantRoute object by their ShellSetting. This way there would just be one lookup.
// And the ShellSettings test in TenantRoute would also be useless.
foreach (var startup in startups)
{
startup.Configure(appBuilder, prefixedRouteBuilder, serviceProvider);
}
// The default route is added to each tenant as a template route, with a prefix
prefixedRouteBuilder.Routes.Add(new Route(
prefixedRouteBuilder.DefaultHandler,
"Default",
"{area:exists}/{controller}/{action}/{id?}",
null,
null,
null,
inlineConstraintResolver)
);
var router = prefixedRouteBuilder.Build();
appBuilder.UseRouter(router);
var pipeline = appBuilder.Build();
return(pipeline);
}
public RouteChain(MethodCall action, string url)
{
Action = action;
Route = RouteBuilder.Build(url, action.HandlerType, action.Method);
TypeName = $"{Action.HandlerType.FullName.Replace(".", "_")}_{action.Method.Name}";
InputType = RouteBuilder.DetermineInputType(action.Method);
ResourceType = action.ReturnVariable?.VariableType;
Route.Chain = this;
}
// This method gets called by the runtime. Use this method
// to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app)
{
app.UseResponseCompression();
var routeBuilder = new RouteBuilder(app);
routeBuilder.MapGet("metrics", Collect);
routeBuilder.MapGet("ping", context => context.Response.WriteAsync("pong"));
app.UseRouter(routeBuilder.Build());
}
public void Configure(IApplicationBuilder app)
{
var routeBuilder = new RouteBuilder(app);
routeBuilder.MapGet("", (context) => context.Response.WriteAsync(response));
routeBuilder.MapGet("time", (context) => context.Response.WriteAsync($"The Time is: {DateTime.Now.ToString("hh:mm:ss tt")}"));
var routes = routeBuilder.Build();
app.UseRouter(routes);
}
public void Configure(BehaviorGraph graph)
{
graph.Behaviors.Where(chain => chain.Route == null && chain.HasResourceType()).Each(chain =>
{
chain.ResourceType().ForAttribute <UrlPatternAttribute>(att =>
{
chain.IsPartialOnly = false;
chain.Route = RouteBuilder.Build(chain.ResourceType(), att.Pattern);
});
});
}
/// <summary>
/// Initializes a new instance of the routing configuration class.
/// </summary>
/// <returns>A new instance of the routing configuration class.</returns>
public static IRouteBuilder Create()
{
IServiceCollection serviceCollection = new ServiceCollection();
serviceCollection.AddMvc();
serviceCollection.AddSingleton <ObjectPoolProvider, DefaultObjectPoolProvider>();
serviceCollection.AddSingleton <ILoggerFactory>(NullLoggerFactory.Instance);
serviceCollection.AddOData();
// For routing tests, add an IActionDescriptorCollectionProvider.
serviceCollection.AddSingleton <IActionDescriptorCollectionProvider, TestActionDescriptorCollectionProvider>();
// Add an action select to return a default descriptor.
var mockAction = new Mock <ActionDescriptor>();
ActionDescriptor actionDescriptor = mockAction.Object;
var mockActionSelector = new Mock <IActionSelector>();
mockActionSelector
.Setup(a => a.SelectCandidates(It.IsAny <RouteContext>()))
.Returns(new ActionDescriptor[] { actionDescriptor });
mockActionSelector
.Setup(a => a.SelectBestCandidate(It.IsAny <RouteContext>(), It.IsAny <IReadOnlyList <ActionDescriptor> >()))
.Returns(actionDescriptor);
// Add a mock action invoker & factory.
var mockInvoker = new Mock <IActionInvoker>();
mockInvoker.Setup(i => i.InvokeAsync())
.Returns(Task.FromResult(true));
var mockInvokerFactory = new Mock <IActionInvokerFactory>();
mockInvokerFactory.Setup(f => f.CreateInvoker(It.IsAny <ActionContext>()))
.Returns(mockInvoker.Object);
// Create a logger, diagnostic source and app builder.
var mockLoggerFactory = new Mock <ILoggerFactory>();
var diagnosticSource = new DiagnosticListener("Microsoft.AspNetCore");
IApplicationBuilder appBuilder = new ApplicationBuilder(serviceCollection.BuildServiceProvider());
// Create a route build with a default path handler.
IRouteBuilder routeBuilder = new RouteBuilder(appBuilder);
routeBuilder.DefaultHandler = new MvcRouteHandler(
mockInvokerFactory.Object,
mockActionSelector.Object,
diagnosticSource,
mockLoggerFactory.Object,
new ActionContextAccessor());
return(routeBuilder);
}
private static void ConfigureDefaultRoute(IApplicationBuilder app)
{
var routeBuilder = new RouteBuilder(app);
routeBuilder.MapGet("/", context =>
{
return(context.Response.WriteAsync("Api now is running."));
});
app.UseRouter(routeBuilder.Build());
}
/*
* Set up URL handling for the Controller API.
* URLs are listed above, in the initial file header.
*/
private IRouter BuildRoutes(IApplicationBuilder app)
{
RouteBuilder routeBuilder = new RouteBuilder(app, new RouteHandler(null));
routeBuilder.MapGet("", ShowServiceDescription);
routeBuilder.MapGet("index", ShowServiceDescription);
routeBuilder.MapPost("upload", StartUpload);
return(routeBuilder.Build());
}
// Build the middleware pipeline for the current tenant
public RequestDelegate BuildTenantPipeline(ShellSettings shellSettings, IServiceProvider serviceProvider)
{
var startups = serviceProvider.GetServices<IStartup>();
var inlineConstraintResolver = serviceProvider.GetService<IInlineConstraintResolver>();
IApplicationBuilder appBuilder = new ApplicationBuilder(serviceProvider);
string routePrefix = "";
if (!string.IsNullOrWhiteSpace(shellSettings.RequestUrlPrefix))
{
routePrefix = shellSettings.RequestUrlPrefix + "/";
}
var routeBuilder = new RouteBuilder(appBuilder)
{
DefaultHandler = appBuilder.ApplicationServices.GetRequiredService<MvcRouteHandler>()
};
var prefixedRouteBuilder = new PrefixedRouteBuilder(routePrefix, routeBuilder, inlineConstraintResolver);
// Register one top level TenantRoute per tenant. Each instance contains all the routes
// for this tenant.
// In the case of several tenants, they will all be checked by ShellSettings. To optimize
// the TenantRoute resolution we can create a single Router type that would index the
// TenantRoute object by their ShellSetting. This way there would just be one lookup.
// And the ShellSettings test in TenantRoute would also be useless.
foreach (var startup in startups)
{
startup.Configure(appBuilder, prefixedRouteBuilder, serviceProvider);
}
// The default route is added to each tenant as a template route, with a prefix
prefixedRouteBuilder.Routes.Add(new Route(
prefixedRouteBuilder.DefaultHandler,
"Default",
"{area:exists}/{controller}/{action}/{id?}",
null,
null,
null,
inlineConstraintResolver)
);
var router = prefixedRouteBuilder.Build();
appBuilder.UseRouter(router);
var pipeline = appBuilder.Build();
return pipeline;
}
public void Configure(IApplicationBuilder app)
{
app.UseCors(policy => policy
.AllowAnyHeader()
.AllowAnyMethod()
.AllowAnyOrigin()
.AllowCredentials()
);
var builder = new RouteBuilder(app);
((HttpCommandRouteMapper)app.ApplicationServices.GetService(typeof(HttpCommandRouteMapper))).Map(builder);
((HttpQueryRouteMapper)app.ApplicationServices.GetService(typeof(HttpQueryRouteMapper))).Map(builder);
app.UseRouter(builder.Build());
}
/// <summary>
///
/// </summary>
/// <param name="app"></param>
/// <param name="rpcConfig"></param>
public static void Initialize(IApplicationBuilder app, RpcConfig rpcConfig)
{
RpcManager.Initialize(rpcConfig);
if (rpcConfig?.Service?.Paths == null) return;
if (app == null) return;
var routers = new RouteBuilder(app);
foreach (var path in rpcConfig.Service.Paths)
{
routers.MapRoute(path + "{*RpcLiteServicePath}", context => RpcManager.ProcessAsync(new AspNetCoreServerContext(context)));
}
var routes1 = routers.Build();
app.UseRouter(routes1);
}
// Routes must configured in Configure
public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory)
{
var trackPackageRouteHandler = new RouteHandler(context =>
{
var routeValues = context.GetRouteData().Values;
return context.Response.WriteAsync(
$"Hello! Route values: {string.Join(", ", routeValues)}");
});
var routeBuilder = new RouteBuilder(app, trackPackageRouteHandler);
routeBuilder.MapRoute(
"Track Package Route",
"package/{operation:regex(track|create|detonate)}/{id:int}");
routeBuilder.MapGet("hello/{name}", context =>
{
var name = context.GetRouteValue("name");
// This is the route handler when HTTP GET "hello/<anything>" matches
// To match HTTP GET "hello/<anything>/<anything>,
// use routeBuilder.MapGet("hello/{*name}"
return context.Response.WriteAsync($"Hi, {name}!");
});
var routes = routeBuilder.Build();
app.UseRouter(routes);
// Show link generation when no routes match.
app.Run(async (context) =>
{
var dictionary = new RouteValueDictionary
{
{ "operation", "create" },
{ "id", 123}
};
var vpc = new VirtualPathContext(context, null, dictionary, "Track Package Route");
var path = routes.GetVirtualPath(vpc).VirtualPath;
context.Response.ContentType = "text/html";
await context.Response.WriteAsync("Menu<hr/>");
await context.Response.WriteAsync($"<a href='{path}'>Create Package 123</a><br/>");
});
// End of app.Run
}
public void Ctor_SetsPropertyValues()
{
// Arrange
var services = new ServiceCollection();
services.AddSingleton(typeof(RoutingMarkerService));
var applicationServices = services.BuildServiceProvider();
var applicationBuilderMock = new Mock<IApplicationBuilder>();
applicationBuilderMock.Setup(a => a.ApplicationServices).Returns(applicationServices);
var applicationBuilder = applicationBuilderMock.Object;
var defaultHandler = Mock.Of<IRouter>();
// Act
var builder = new RouteBuilder(applicationBuilder, defaultHandler);
// Assert
Assert.Same(applicationBuilder, builder.ApplicationBuilder);
Assert.Same(defaultHandler, builder.DefaultHandler);
Assert.Same(applicationServices, builder.ServiceProvider);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app,
ILoggerFactory loggerFactory)
{
loggerFactory.AddConsole(minLevel: LogLevel.Trace);
var defaultHandler = new RouteHandler((c) =>
c.Response.WriteAsync($"Hello world! Route values: " +
$"{string.Join(", ", c.GetRouteData().Values)}")
);
var routeBuilder = new RouteBuilder(app, defaultHandler);
routeBuilder.AddHelloRoute(app);
routeBuilder.MapRoute(
"Track Package Route",
"package/{operation:regex(track|create|detonate)}/{id:int}");
app.UseRouter(routeBuilder.Build());
// demonstrate link generation
var trackingRouteCollection = new RouteCollection();
trackingRouteCollection.Add(routeBuilder.Routes[1]); // "Track Package Route"
app.Run(async (context) =>
{
var dictionary = new RouteValueDictionary
{
{"operation","create" },
{"id",123}
};
var vpc = new VirtualPathContext(context,
null, dictionary, "Track Package Route");
context.Response.ContentType = "text/html";
await context.Response.WriteAsync("Menu<hr/>");
await context.Response.WriteAsync(@"<a href='" +
trackingRouteCollection.GetVirtualPath(vpc).VirtualPath +
"'>Create Package 123</a><br/>");
});
}
public void Map(RouteBuilder builder)
{
foreach (var command in Locator.LocateWithAttribute<HttpCommandAttribute>()) {
_logger.LogDebug("Mapping {0} to command {1}", command.GetTypeInfo().GetCustomAttribute<HttpCommandAttribute>().Template, command);
switch (command.GetTypeInfo().GetCustomAttribute<HttpCommandAttribute>().Method) {
case "POST":
builder.MapPost(
command.GetTypeInfo().GetCustomAttribute<HttpCommandAttribute>().Template,
new HttpCommandDispatcher(_logger, _authorizer, _dispatcher, command).Dispatch
);
break;
case "GET":
builder.MapGet(
command.GetTypeInfo().GetCustomAttribute<HttpCommandAttribute>().Template,
new HttpCommandDispatcher(_logger, _authorizer, _dispatcher, command).Dispatch
);
break;
}
}
}
public void Map(RouteBuilder builder)
{
foreach (var query in Locator.LocateWithAttribute<HttpQueryAttribute>()) {
_logger.LogDebug("Mapping {0} to query {1}", query.GetTypeInfo().GetCustomAttribute<HttpQueryAttribute>().Template, query);
switch (query.GetTypeInfo().GetCustomAttribute<HttpQueryAttribute>().Method) {
case "POST":
builder.MapPost(
query.GetTypeInfo().GetCustomAttribute<HttpQueryAttribute>().Template,
new HttpQueryProcessor(_logger, _authorizer, _processor, query).Process
);
break;
case "GET":
builder.MapGet(
query.GetTypeInfo().GetCustomAttribute<HttpQueryAttribute>().Template,
new HttpQueryProcessor(_logger, _authorizer, _processor, query).Process
);
break;
}
}
}
private static RouteBuilder GetRouteBuilder(IServiceProvider serviceProvider)
{
var app = new Mock<IApplicationBuilder>(MockBehavior.Strict);
app
.SetupGet(a => a.ApplicationServices)
.Returns(serviceProvider);
var builder = new RouteBuilder(app.Object);
var handler = new Mock<IRouter>(MockBehavior.Strict);
handler
.Setup(router => router.GetVirtualPath(It.IsAny<VirtualPathContext>()))
.Returns((VirtualPathData)null);
builder.DefaultHandler = handler.Object;
return builder;
}
public NancyRouteModule(NancyServerAdapter adapter)
{
foreach (KeyValuePair<IARoute, Action<IARequest, IAResponse>> kvp in adapter.Routes)
{
IARoute route = kvp.Key;
Action<IARequest, IAResponse> action = kvp.Value;
RouteBuilder rb = new RouteBuilder(route.Action, this);
rb[route.Resource] = nancyDynamicDictionary =>
{
Dictionary<string, string> parameters = new Dictionary<string, string>();
// get parameters out of path
foreach (string key in nancyDynamicDictionary)
{
DynamicDictionaryValue value = nancyDynamicDictionary[key];
string urldecoded = HttpUtility.UrlDecode(value.ToString());
parameters.Add(key, urldecoded);
}
// get parameters out of query string
foreach (string key in Request.Query)
{
DynamicDictionaryValue value = Request.Query[key];
parameters.Add(key, "" + value.Value);
}
string contentType = Request.Headers.ContentType;
IADevice origin = null;
if (Request.Headers.Keys.Contains("X-IA-Origin"))
{
IAIntAirAct intAirAct = TinyIoC.TinyIoCContainer.Current.Resolve<IAIntAirAct>();
if (intAirAct != null)
{
origin = intAirAct.DeviceWithName(Request.Headers["X-IA-Origin"].First());
}
}
Dictionary<string, string> metadata = new Dictionary<string, string>();
foreach (KeyValuePair<string, IEnumerable<string>> header in Request.Headers)
{
var value = header.Value.First();
metadata[header.Key] = value;
}
IARequest iaRequest = new IARequest(route, metadata, parameters, origin, Request.BodyAsByte(), contentType);
IAResponse iaResponse = new IAResponse();
action(iaRequest, iaResponse);
Response response = new Response();
response.StatusCode = (HttpStatusCode)iaResponse.StatusCode;
response.Contents = stream =>
{
var writer = new BinaryWriter(stream);
writer.Write(iaResponse.Body);
writer.Flush();
};
response.Headers = iaResponse.Metadata;
response.ContentType = iaResponse.ContentType;
return response;
};
}
}
private static void PrepareApplicationAndRouting(StartupMethods startupMethods)
{
var applicationBuilder = new ApplicationBuilderMock(serviceProvider);
startupMethods?.ConfigureDelegate?.Invoke(applicationBuilder);
AdditionalApplicationConfiguration?.Invoke(applicationBuilder);
var routeBuilder = new RouteBuilder(applicationBuilder)
{
DefaultHandler = new RouteHandler(NullHandler)
};
for (int i = 0; i < applicationBuilder.Routes.Count; i++)
{
var route = applicationBuilder.Routes[i];
routeBuilder.Routes.Add(route);
}
AdditionalRouting?.Invoke(routeBuilder);
if (StartupType == null || routeBuilder.Routes.Count == 0)
{
routeBuilder.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
routeBuilder.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute(serviceProvider));
}
router = routeBuilder.Build();
}
private static IRouteBuilder CreateRouteBuilder(IServiceProvider services)
{
var applicationBuilder = new Mock<IApplicationBuilder>();
applicationBuilder.SetupAllProperties();
applicationBuilder
.Setup(b => b.New().Build())
.Returns(NullHandler);
applicationBuilder.Object.ApplicationServices = services;
var routeBuilder = new RouteBuilder(applicationBuilder.Object);
return routeBuilder;
}
private void Register(RouteBuilder routeBuilder, string path, Func<dynamic, PomonaResponse> handler)
{
routeBuilder[path] = x =>
{
try
{
var pomonaResponse = (PomonaResponse)handler(x);
if ((int)pomonaResponse.StatusCode >= 400)
SetErrorHandled();
return pomonaResponse;
}
catch (Exception ex)
{
var error = OnException(UnwrapException(ex));
if (error == null)
throw;
SetErrorHandled();
return new PomonaResponse(error.Entity ?? PomonaResponse.NoBodyEntity,
error.StatusCode,
responseHeaders : error.ResponseHeaders);
}
};
}
private static IRouteBuilder CreateRouteBuilder()
{
var services = new ServiceCollection();
services.AddSingleton<IInlineConstraintResolver>(_inlineConstraintResolver);
services.AddSingleton<RoutingMarkerService>();
var applicationBuilder = Mock.Of<IApplicationBuilder>();
applicationBuilder.ApplicationServices = services.BuildServiceProvider();
var routeBuilder = new RouteBuilder(applicationBuilder);
routeBuilder.DefaultHandler = Mock.Of<IRouter>();
return routeBuilder;
}
private static IRouteBuilder CreateRouteBuilder()
{
var routeBuilder = new RouteBuilder();
routeBuilder.DefaultHandler = new Mock<IRouter>().Object;
var serviceProviderMock = new Mock<IServiceProvider>();
serviceProviderMock.Setup(o => o.GetService(typeof(IInlineConstraintResolver)))
.Returns(_inlineConstraintResolver);
routeBuilder.ServiceProvider = serviceProviderMock.Object;
return routeBuilder;
}
