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; }