tk/Ocelot
1
0
Fork 0
mirror of https://github.com/nsnail/Ocelot.git synced 2025-06-19 07:18:16 +08:00
Code Issues Packages Projects Releases Wiki Activity

allowing people to inject functions as custom middleware

Browse Source
This commit is contained in:
tom.pallister
2016-10-19 19:32:05 +01:00
parent b8951c4698
commit ab5d7fa33d
10 changed files with 320 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
src/Ocelot/Configuration/Provider/YamlOcelotConfigurationProvider.cs → src/Ocelot/Configuration/Provider/OcelotConfigurationProvider.cs
View File

@ -7,12 +7,12 @@ namespace Ocelot.Configuration.Provider
/// <summary>
/// Register as singleton
/// </summary>
public class YamlOcelotConfigurationProvider : IOcelotConfigurationProvider
public class OcelotConfigurationProvider : IOcelotConfigurationProvider
{
private readonly IOcelotConfigurationRepository _repo;
private readonly IOcelotConfigurationCreator _creator;
public YamlOcelotConfigurationProvider(IOcelotConfigurationRepository repo,
public OcelotConfigurationProvider(IOcelotConfigurationRepository repo,
IOcelotConfigurationCreator creator)
{
_repo = repo;
@ -21,28 +21,28 @@ namespace Ocelot.Configuration.Provider
public Response<IOcelotConfiguration> Get()
{
var config = _repo.Get();
var repoConfig = _repo.Get();
if (config.IsError)
if (repoConfig.IsError)
{
return new ErrorResponse<IOcelotConfiguration>(config.Errors);
return new ErrorResponse<IOcelotConfiguration>(repoConfig.Errors);
}
if (config.Data == null)
if (repoConfig.Data == null)
{
var configuration = _creator.Create();
var creatorConfig = _creator.Create();
if (configuration.IsError)
if (creatorConfig.IsError)
{
return new ErrorResponse<IOcelotConfiguration>(configuration.Errors);
return new ErrorResponse<IOcelotConfiguration>(creatorConfig.Errors);
}
_repo.AddOrReplace(configuration.Data);
_repo.AddOrReplace(creatorConfig.Data);
return new OkResponse<IOcelotConfiguration>(configuration.Data);
return new OkResponse<IOcelotConfiguration>(creatorConfig.Data);
}
return new OkResponse<IOcelotConfiguration>(config.Data);
return new OkResponse<IOcelotConfiguration>(repoConfig.Data);
}
}
}

2
src/Ocelot/DependencyInjection/ServiceCollectionExtensions.cs
View File

@ -34,7 +34,7 @@ namespace Ocelot.DependencyInjection
// ocelot services.
services.AddSingleton<IOcelotConfigurationCreator, YamlOcelotConfigurationCreator>();
services.AddSingleton<IOcelotConfigurationProvider, YamlOcelotConfigurationProvider>();
services.AddSingleton<IOcelotConfigurationProvider, OcelotConfigurationProvider>();
services.AddSingleton<IOcelotConfigurationRepository, InMemoryOcelotConfigurationRepository>();
services.AddSingleton<IClaimToThingConfigurationParser, ClaimToThingConfigurationParser>();
services.AddSingleton<IConfigurationValidator, ConfigurationValidator>();

27
src/Ocelot/Middleware/OcelotMiddlewareConfiguration.cs Normal file
View File

@ -0,0 +1,27 @@
namespace Ocelot.Middleware
{
using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
public class OcelotMiddlewareConfiguration
{
public Func<HttpContext, Func<Task>, Task> PreHttpResponderMiddleware { get; set; }
public Func<HttpContext, Func<Task>, Task> PostHttpResponderMiddleware { get; set; }
public Func<HttpContext, Func<Task>, Task> PreDownstreamRouteFinderMiddleware { get; set; }
public Func<HttpContext, Func<Task>, Task> PostDownstreamRouteFinderMiddleware { get; set; }
public Func<HttpContext, Func<Task>, Task> PreAuthenticationMiddleware { get; set; }
public Func<HttpContext, Func<Task>, Task> PostAuthenticationMiddleware { get; set; }
public Func<HttpContext, Func<Task>, Task> PreClaimsBuilderMiddleware { get; set; }
public Func<HttpContext, Func<Task>, Task> PostClaimsBuilderMiddleware { get; set; }
public Func<HttpContext, Func<Task>, Task> PreAuthorisationMiddleware { get; set; }
public Func<HttpContext, Func<Task>, Task> PostAuthorisationMiddleware { get; set; }
public Func<HttpContext, Func<Task>, Task> PreHttpRequestHeadersBuilderMiddleware { get; set; }
public Func<HttpContext, Func<Task>, Task> PostHttpRequestHeadersBuilderMiddleware { get; set; }
public Func<HttpContext, Func<Task>, Task> PreDownstreamUrlCreatorMiddleware { get; set; }
public Func<HttpContext, Func<Task>, Task> PostDownstreamUrlCreatorMiddleware { get; set; }
public Func<HttpContext, Func<Task>, Task> PreHttpRequestBuilderMiddleware { get; set; }
public Func<HttpContext, Func<Task>, Task> PostHttpRequestBuilderMiddleware { get; set; }
public Func<HttpContext, Func<Task>, Task> PreHttpRequesterMiddleware { get; set; }
}
}

68
src/Ocelot/Middleware/OcelotMiddlewareExtensions.cs
View File

@ -9,8 +9,11 @@ using Ocelot.Responder.Middleware;
namespace Ocelot.Middleware
{
using System;
using System.Threading.Tasks;
using Authorisation.Middleware;
using ClaimsBuilder.Middleware;
using Microsoft.AspNetCore.Http;
public static class OcelotMiddlewareExtensions
{
@ -36,5 +39,70 @@ namespace Ocelot.Middleware
return builder;
}
public static IApplicationBuilder UseOcelot(this IApplicationBuilder builder, OcelotMiddlewareConfiguration middlewareConfiguration)
{
builder.UseIfNotNull(middlewareConfiguration.PreHttpResponderMiddleware);
builder.UseHttpResponderMiddleware();
builder.UseIfNotNull(middlewareConfiguration.PostHttpResponderMiddleware);
builder.UseIfNotNull(middlewareConfiguration.PreDownstreamRouteFinderMiddleware);
builder.UseDownstreamRouteFinderMiddleware();
builder.UseIfNotNull(middlewareConfiguration.PostDownstreamRouteFinderMiddleware);
builder.UseIfNotNull(middlewareConfiguration.PreAuthenticationMiddleware);
builder.UseAuthenticationMiddleware();
builder.UseIfNotNull(middlewareConfiguration.PostAuthenticationMiddleware);
builder.UseIfNotNull(middlewareConfiguration.PreClaimsBuilderMiddleware);
builder.UseClaimsBuilderMiddleware();
builder.UseIfNotNull(middlewareConfiguration.PostClaimsBuilderMiddleware);
builder.UseIfNotNull(middlewareConfiguration.PreAuthorisationMiddleware);
builder.UseAuthorisationMiddleware();
builder.UseIfNotNull(middlewareConfiguration.PostAuthorisationMiddleware);
builder.UseIfNotNull(middlewareConfiguration.PreHttpRequestHeadersBuilderMiddleware);
builder.UseHttpRequestHeadersBuilderMiddleware();
builder.UseIfNotNull(middlewareConfiguration.PostHttpRequestHeadersBuilderMiddleware);
builder.UseIfNotNull(middlewareConfiguration.PreDownstreamUrlCreatorMiddleware);
builder.UseDownstreamUrlCreatorMiddleware();
builder.UseIfNotNull(middlewareConfiguration.PostDownstreamUrlCreatorMiddleware);
builder.UseIfNotNull(middlewareConfiguration.PreHttpRequestBuilderMiddleware);
builder.UseHttpRequestBuilderMiddleware();
builder.UseIfNotNull(middlewareConfiguration.PostHttpRequestBuilderMiddleware);
builder.UseIfNotNull(middlewareConfiguration.PreHttpRequesterMiddleware);
builder.UseHttpRequesterMiddleware();
return builder;
}
private static void UseIfNotNull(this IApplicationBuilder builder, Func<HttpContext, Func<Task>, Task> middleware)
{
if (middleware != null)
{
builder.Use(middleware);
}
}
}
}