public void Contstructor_BindsConfigurationCorrectly()
{
var appsettings = new Dictionary <string, string>()
{
["management:endpoints:enabled"] = "false",
["management:endpoints:loggers:enabled"] = "false",
["management:endpoints:cloudfoundry:validatecertificates"] = "true",
["management:endpoints:cloudfoundry:enabled"] = "true"
};
ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
configurationBuilder.AddInMemoryCollection(appsettings);
var config = configurationBuilder.Build();
var opts = new LoggersEndpointOptions(config);
CloudFoundryEndpointOptions cloudOpts = new CloudFoundryEndpointOptions(config);
Assert.True(cloudOpts.Enabled);
Assert.Equal(string.Empty, cloudOpts.Id);
Assert.Equal(string.Empty, cloudOpts.Path);
Assert.True(cloudOpts.ValidateCertificates);
Assert.False(opts.Enabled);
Assert.Equal("loggers", opts.Id);
Assert.Equal("loggers", opts.Path);
}
/// <summary>
/// Add Loggers actuator endpoint to OWIN Pipeline
/// </summary>
/// <param name="builder">OWIN <see cref="IAppBuilder" /></param>
/// <param name="config"><see cref="IConfiguration"/> of application for configuring loggers endpoint</param>
/// <param name="loggerProvider">Provider of loggers to report on and configure</param>
/// <param name="loggerFactory">For logging within the middleware</param>
/// <returns>OWIN <see cref="IAppBuilder" /> with Loggers Endpoint added</returns>
public static IAppBuilder UseLoggersActuator(this IAppBuilder builder, IConfiguration config, ILoggerProvider loggerProvider, ILoggerFactory loggerFactory = null)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
if (loggerProvider == null)
{
throw new ArgumentNullException(nameof(loggerProvider));
}
var options = new LoggersEndpointOptions(config);
var mgmtOptions = ManagementOptions.Get(config);
foreach (var mgmt in mgmtOptions)
{
mgmt.EndpointOptions.Add(options);
}
var endpoint = new LoggersEndpoint(options, loggerProvider as IDynamicLoggerProvider, loggerFactory?.CreateLogger <LoggersEndpoint>());
var logger = loggerFactory?.CreateLogger <LoggersEndpointOwinMiddleware>();
return(builder.Use <LoggersEndpointOwinMiddleware>(endpoint, mgmtOptions, logger));
}
public void Constructor_InitializesWithDefaults()
{
var opts = new LoggersEndpointOptions();
Assert.Null(opts.Enabled);
Assert.Equal("loggers", opts.Id);
}
/// <summary>
/// Register the Loggers endpoint, middleware and options<para />Steeltoe's <see cref="DynamicConsoleLogger"/> will be configured and included in the DI container
/// </summary>
/// <param name="container">Autofac DI <see cref="ContainerBuilder"/></param>
/// <param name="config">Your application's <see cref="IConfiguration"/></param>
/// <param name="loggerProvider">Your pre-existing <see cref="DynamicLoggerProvider"/> will be created if not provided</param>
/// <param name="loggerFactory">Your pre-existing <see cref="ILoggerFactory"/>. A new <see cref="LoggerFactory"/> will be added if not provided</param>
public static void RegisterLoggersActuator(this ContainerBuilder container, IConfiguration config, DynamicLoggerProvider loggerProvider = null, ILoggerFactory loggerFactory = null)
{
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
if (loggerProvider == null)
{
loggerProvider = new DynamicLoggerProvider(new ConsoleLoggerSettings().FromConfiguration(config));
}
container.RegisterLogging(config);
container.RegisterInstance(loggerProvider).As <IDynamicLoggerProvider>();
container.Register(c =>
{
var options = new LoggersEndpointOptions(config);
var mgmtOptions = c.Resolve <IEnumerable <IManagementOptions> >();
foreach (var mgmt in mgmtOptions)
{
mgmt.EndpointOptions.Add(options);
}
return(options);
}).As <ILoggersOptions>().IfNotRegistered(typeof(ILoggersOptions));
container.RegisterType <LoggersEndpoint>().SingleInstance();
container.RegisterType <LoggersEndpointOwinMiddleware>().SingleInstance();
}
public void RoutesByPathAndVerb()
{
var options = new LoggersEndpointOptions();
Assert.False(options.ExactMatch);
Assert.Equal("/actuator/loggers/{**_}", options.GetContextPath(new ActuatorManagementOptions()));
Assert.Equal("/cloudfoundryapplication/loggers/{**_}", options.GetContextPath(new CloudFoundryManagementOptions()));
Assert.Collection(options.AllowedVerbs, verb => Assert.Contains("Get", verb), verb => Assert.Contains("Post", verb));
}
public static void UseLoggerActuator(IConfiguration configuration, ILoggerProvider loggerProvider, ILoggerFactory loggerFactory = null)
{
var options = new LoggersEndpointOptions(configuration);
_mgmtOptions.RegisterEndpointOptions(configuration, options);
var ep = new LoggersEndpoint(options, loggerProvider as IDynamicLoggerProvider, CreateLogger <LoggersEndpoint>(loggerFactory));
var handler = new LoggersHandler(ep, SecurityServices, _mgmtOptions, CreateLogger <LoggersHandler>(loggerFactory));
ConfiguredHandlers.Add(handler);
}
public async void HandleLoggersRequestAsync_ReturnsExpected()
{
var opts = new LoggersEndpointOptions();
var mopts = TestHelpers.GetManagementOptions(opts);
var ep = new TestLoggersEndpoint(opts);
var middle = new LoggersEndpointMiddleware(null, ep, mopts);
var context = CreateRequest("GET", "/loggers");
await middle.HandleLoggersRequestAsync(context);
context.Response.Body.Seek(0, SeekOrigin.Begin);
StreamReader rdr = new StreamReader(context.Response.Body);
string json = await rdr.ReadToEndAsync();
Assert.Equal("{}", json);
}
public void LoggersEndpointMiddleware_PathAndVerbMatching_ReturnsExpected()
{
var opts = new LoggersEndpointOptions();
var mopts = TestHelpers.GetManagementOptions(opts);
var ep = new LoggersEndpoint(opts, (IDynamicLoggerProvider)null);
var middle = new LoggersEndpointMiddleware(null, ep, mopts);
Assert.True(middle.RequestVerbAndPathMatch("GET", "/cloudfoundryapplication/loggers"));
Assert.False(middle.RequestVerbAndPathMatch("PUT", "/cloudfoundryapplication/loggers"));
Assert.False(middle.RequestVerbAndPathMatch("GET", "/cloudfoundryapplication/badpath"));
Assert.True(middle.RequestVerbAndPathMatch("POST", "/cloudfoundryapplication/loggers"));
Assert.False(middle.RequestVerbAndPathMatch("POST", "/cloudfoundryapplication/badpath"));
Assert.True(middle.RequestVerbAndPathMatch("POST", "/cloudfoundryapplication/loggers/Foo.Bar.Class"));
Assert.False(middle.RequestVerbAndPathMatch("POST", "/cloudfoundryapplication/badpath/Foo.Bar.Class"));
}
/// <summary>
/// Adds the services used by the Loggers actuator
/// </summary>
/// <param name="services">Reference to the service collection</param>
/// <param name="configuration">Reference to the configuration system</param>
/// <returns>A reference to the service collection</returns>
public static IServiceCollection AddLoggersActuatorServices(this IServiceCollection services, IConfiguration configuration)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
var options = new LoggersEndpointOptions(configuration);
services.TryAddSingleton <ILoggersOptions>(options);
services.TryAddEnumerable(ServiceDescriptor.Singleton(typeof(IEndpointOptions), options));
services.TryAddSingleton <LoggersEndpoint>();
return(services);
}
