public LoggerMiddlewate(CustomRequestDelegate next, ICustomLogger log, IOptions <LogOptions> options)
{
_next = next;
_log = log;
_logOptions = options.Value;
}
public ResponderMiddleware(CustomRequestDelegate next, ICustomLogger log)
{
_next = next;
_responder = new HttpResponser();
_log = log;
}
public CustomRequestDelegate Build()
{
CustomRequestDelegate app = context =>
{
context.HttpContext.Response.StatusCode = 404;
return(Task.CompletedTask);
};
foreach (var component in _middlewares.Reverse())
{
app = component(app);
}
return(app);
}
public AuthorizationMiddleware(CustomRequestDelegate next)
{
_next = next;
}
public RouteFinderMiddleware(CustomRequestDelegate next)
{
_next = next;
}
public static IPipelineBuilder UseMiddleware(this IPipelineBuilder app, Type middleware, params object[] args)
{
return(app.Use(next =>
{
var methods = middleware.GetMethods(BindingFlags.Instance | BindingFlags.Public);
var invokeMethods = methods.Where(m =>
string.Equals(m.Name, InvokeMethodName, StringComparison.Ordinal) ||
string.Equals(m.Name, InvokeAsyncMethodName, StringComparison.Ordinal)
).ToArray();
if (invokeMethods.Length > 1)
{
throw new InvalidOperationException();
}
if (invokeMethods.Length == 0)
{
throw new InvalidOperationException();
}
var methodinfo = invokeMethods[0];
if (!typeof(Task).IsAssignableFrom(methodinfo.ReturnType))
{
throw new InvalidOperationException();
}
var parameters = methodinfo.GetParameters();
if (parameters.Length == 0 || parameters[0].ParameterType != typeof(DownstreamContext))
{
throw new InvalidOperationException();
}
var ctorArgs = new object[args.Length + 1];
ctorArgs[0] = next;
Array.Copy(args, 0, ctorArgs, 1, args.Length);
var instance = ActivatorUtilities.CreateInstance(app.ApplicationServices, middleware, ctorArgs);
if (parameters.Length == 1)
{
var ocelotDelegate = (CustomRequestDelegate)methodinfo.CreateDelegate(typeof(CustomRequestDelegate), instance);
var diagnosticListener = (DiagnosticListener)app.ApplicationServices.GetService(typeof(DiagnosticListener));
var middlewareName = ocelotDelegate.Target.GetType().Name;
CustomRequestDelegate wrapped = context =>
{
try
{
Write(diagnosticListener, "Ocelot.MiddlewareStarted", middlewareName, context);
return ocelotDelegate(context);
}
catch (Exception ex)
{
WriteException(diagnosticListener, ex, "Ocelot.MiddlewareException", middlewareName, context);
throw ex;
}
finally
{
Write(diagnosticListener, "Ocelot.MiddlewareFinished", middlewareName, context);
}
};
return wrapped;
}
var factory = Compile <object>(methodinfo, parameters);
return context =>
{
var serviceProvider = context.HttpContext.RequestServices ?? app.ApplicationServices;
if (serviceProvider == null)
{
throw new InvalidOperationException();
}
return factory(instance, context, serviceProvider);
};
}));
}
public RequesterMiddleware(CustomRequestDelegate next)
{
_next = next;
_httpClient = new HttpClientExtension();
}
