public static void Main(string[] args)
{
var builder = WebApplication.CreateBuilder(args);
// Additional configuration is required to successfully run gRPC on macOS.
// For instructions on how to configure Kestrel and gRPC clients on macOS, visit https://go.microsoft.com/fwlink/?linkid=2099682
// Add services to the container.
builder.Services.AddGrpc();
var app = builder.Build();
// Configure the HTTP request pipeline.
app.MapGrpcService <GreeterService>();
app.MapGet("/", () => "Communication with gRPC endpoints must be made through a gRPC client. To learn how to create a client, visit: https://go.microsoft.com/fwlink/?linkid=2086909");
app.Run();
}
public async Task WebApplicationUrls_UpdatesIServerAddressesFeature()
{
var builder = WebApplication.CreateBuilder();
var urls = new List <string>();
var server = new MockAddressesServer(urls);
builder.Services.AddSingleton <IServer>(server);
await using var app = builder.Build();
app.Urls.Add("http://localhost:5002");
app.Urls.Add("https://localhost:5003");
await app.StartAsync();
Assert.Equal(2, urls.Count);
Assert.Equal("http://localhost:5002", urls[0]);
Assert.Equal("https://localhost:5003", urls[1]);
}
public async static Task <int> Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
#if DEBUG
.MinimumLevel.Debug()
#else
.MinimumLevel.Information()
#endif
.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
.MinimumLevel.Override("Microsoft.EntityFrameworkCore", LogEventLevel.Warning)
.Enrich.FromLogContext()
.WriteTo.Async(c => c.File("Logs/logs.txt"))
#if DEBUG
.WriteTo.Async(c => c.Console())
#endif
.CreateLogger();
try
{
Log.Information("Starting DataBasePerformanceLab.HttpApi.Host.");
var builder = WebApplication.CreateBuilder(args);
builder.Host.AddAppSettingsSecretsJson()
.UseAutofac()
.UseSerilog();
await builder.AddApplicationAsync <DataBasePerformanceLabHttpApiHostModule>();
var app = builder.Build();
AppContext.SetSwitch("Npgsql.EnableLegacyTimestampBehavior", true);
await app.InitializeApplicationAsync();
await app.RunAsync();
return(0);
}
catch (Exception ex)
{
Log.Fatal(ex, "Host terminated unexpectedly!");
return(1);
}
finally
{
Log.CloseAndFlush();
}
}
private static WebApplication BuildWebApplication(
Tye.Hosting.Model.Application application,
string[] args,
ILogEventSink?sink)
{
var builder = WebApplication.CreateBuilder(args);
// Logging for this application
builder.Host.UseSerilog((context, configuration) =>
{
configuration
.MinimumLevel.Verbose()
.Filter.ByExcluding(Matching.FromSource("Microsoft.AspNetCore"))
.Filter.ByExcluding(Matching.FromSource("Microsoft.Extensions"))
.Filter.ByExcluding(Matching.FromSource("Microsoft.Hosting"))
.Enrich
.FromLogContext()
.WriteTo
.Console();
if (sink is object)
{
configuration.WriteTo.Sink(sink, LogEventLevel.Verbose);
}
});
builder.Services.AddRazorPages(o => o.RootDirectory = "/Dashboard/Pages");
builder.Services.AddServerSideBlazor();
builder.Services.AddOptions <StaticFileOptions>()
.PostConfigure(o =>
{
var fileProvider = new ManifestEmbeddedFileProvider(typeof(TyeHost).Assembly, "wwwroot");
// Make sure we don't remove the existing file providers (blazor needs this)
o.FileProvider = new CompositeFileProvider(o.FileProvider, fileProvider);
});
builder.Services.AddSingleton(application);
var app = builder.Build();
return(app);
}
public async Task WebApplicationBuilder_RegistersAuthenticationMiddlewares()
{
var builder = WebApplication.CreateBuilder();
builder.Authentication.AddJwtBearer();
await using var app = builder.Build();
var webAppAuthBuilder = Assert.IsType <WebApplicationAuthenticationBuilder>(builder.Authentication);
Assert.True(webAppAuthBuilder.IsAuthenticationConfigured);
// Authentication middleware isn't registered until application
// is built on startup
Assert.False(app.Properties.ContainsKey("__AuthenticationMiddlewareSet"));
await app.StartAsync();
Assert.True(app.Properties.ContainsKey("__AuthenticationMiddlewareSet"));
}
public async Task WebApplicationRunUrls_UpdatesIServerAddressesFeature()
{
var builder = WebApplication.CreateBuilder();
var urls = new List <string>();
var server = new MockAddressesServer(urls);
builder.Services.AddSingleton <IServer>(server);
await using var app = builder.Build();
var runTask = app.RunAsync("http://localhost:5001");
var url = Assert.Single(urls);
Assert.Equal("http://localhost:5001", url);
await app.StopAsync();
await runTask;
}
protected override async Task BeforeExecutionAsync(IExecutionContext context)
{
var builder = WebApplication.CreateBuilder();
builder.Logging.ClearProviders();
builder.Services
.AddRazorPages()
.WithRazorPagesRoot("/Statiq.Helpers");
_app = builder.Build();
_app.MapRazorPages();
await _app.StartAsync();
_playwright = await Playwright.CreateAsync();
_browser = await _playwright.Chromium.LaunchAsync();
await base.BeforeExecutionAsync(context);
}
public static void Main(string[] args)
{
var builder = WebApplication.CreateBuilder(new WebApplicationOptions
{
Args = args,
ContentRootPath = Directory.GetCurrentDirectory(),
// etc.
});
// ## Dependency Injection stuff
// -----------------------------------------------------------
var container = new Container(rules =>
// optional: Enables property injection for Controllers
rules.With(propertiesAndFields: request => request.ServiceType.Name.EndsWith("Controller")
? PropertiesAndFields.Properties()(request)
: null));
container.RegisterMyBusinessLogic();
// Here it goes the integration with the existing DryIoc container
var diFactory = new DryIocServiceProviderFactory(container, ExampleOfCustomRegisterDescriptor);
builder.Host.UseServiceProviderFactory(diFactory);
builder.Services
.AddMvc(options => options.EnableEndpointRouting = false)
.AddControllersAsServices();
// other things...
builder.Logging.ClearProviders();
builder.Logging.AddConsole();
//-----------------------------------------------------------
var app = builder.Build();
app.UseMvc();
app.UseHttpsRedirection();
app.UseAuthorization();
app.Run();
}
public static void ConfigureEndpointDefaultsConfigureHttpsDefaults(string[] args)
{
// <snippet_ConfigureEndpointDefaultsConfigureHttpsDefaults>
var builder = WebApplication.CreateBuilder(args);
builder.WebHost.ConfigureKestrel((context, serverOptions) =>
{
serverOptions.ConfigureEndpointDefaults(listenOptions =>
{
// ...
});
serverOptions.ConfigureHttpsDefaults(listenOptions =>
{
// ...
});
});
// </snippet_ConfigureEndpointDefaultsConfigureHttpsDefaults>
}
public async Task PathBaseWorksWithoutUseRoutingWithWebApplication()
{
var builder = WebApplication.CreateBuilder();
builder.WebHost.UseTestServer();
await using var app = builder.Build();
app.UsePathBase("/base");
app.MapGet("/path", context => context.Response.WriteAsync("Response"));
await app.StartAsync();
using var server = app.GetTestServer();
var response = await server.CreateClient().GetStringAsync("/base/path");
Assert.Equal("Response", response);
}
public async static Task <int> Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
#if DEBUG
.MinimumLevel.Debug()
#else
.MinimumLevel.Information()
#endif
.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
.MinimumLevel.Override("Microsoft.EntityFrameworkCore", LogEventLevel.Warning)
.Enrich.FromLogContext()
.WriteTo.Async(c => c.File("Logs/logs.txt"))
#if DEBUG
.WriteTo.Async(c => c.Console())
#endif
.CreateLogger();
try
{
Log.Information("Starting MyCompanyName.MyProjectName.IdentityServer.");
var builder = WebApplication.CreateBuilder(args);
builder.Host.AddAppSettingsSecretsJson()
.UseAutofac()
.UseSerilog();
await builder.AddApplicationAsync <MyProjectNameIdentityServerModule>();
var app = builder.Build();
await app.InitializeApplicationAsync();
await app.RunAsync();
return(0);
}
catch (Exception ex)
{
Log.Fatal(ex, "MyCompanyName.MyProjectName.IdentityServer terminated unexpectedly!");
return(1);
}
finally
{
Log.CloseAndFlush();
}
}
public async Task WebApplicationBuilder_CanRegisterAuthzMiddlewareWithScopedService()
{
var builder = WebApplication.CreateBuilder(new WebApplicationOptions()
{
EnvironmentName = Environments.Development
});
builder.Services.AddAuthorization();
builder.Services.AddScoped <IAuthorizationHandler, TestAuthorizationHandler>();
using var app = builder.Build();
Assert.False(app.Properties.ContainsKey("__AuthenticationMiddlewareSet"));
Assert.False(app.Properties.ContainsKey("__AuthorizationMiddlewareSet"));
await app.StartAsync();
Assert.False(app.Properties.ContainsKey("__AuthenticationMiddlewareSet"));
Assert.True(app.Properties.ContainsKey("__AuthorizationMiddlewareSet"));
}
static async Task Main(string[] args)
{
var builder = WebApplication.CreateBuilder(args);
var jwtSettings = JwtSettings.FromConfiguration(builder.Configuration);
builder.Services.AddIdentityCore <TodoUser>()
.AddEntityFrameworkStores <TodoDbContext>();
builder.Services.AddDbContext <TodoDbContext>(options => options.UseInMemoryDatabase("Todos"));
builder.Services.AddAuthorization(options =>
{
options.AddPolicy("admin", policy => policy.RequireClaim("can_delete", "true"));
options.AddPolicy("user", policy => policy.RequireClaim("can_view", "true"));
});
builder.Services
.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options => options.TokenValidationParameters = jwtSettings.TokenValidationParameters);
var app = builder.Build();
using (var scope = app.Services.CreateScope())
{
var userManager = scope.ServiceProvider.GetService <UserManager <TodoUser> >();
await userManager.CreateAsync(new TodoUser { UserName = "******", IsAdmin = true }, "Pass123456!");
}
app.UseAuthentication();
app.UseAuthorization();
var auth = new AuthApi(jwtSettings);
auth.MapRoutes(app);
var todo = new TodoApi();
todo.MapRoutes(app);
await app.RunAsync();
}
private static WebApplication BuildApplication(string[] args)
{
var builder = WebApplication.CreateBuilder(args);
builder.Logging.AddFileLog();
builder.Services.ConfigureResource <DefaultResourceManager>();
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <IConfigureOptions <MvcRazorRuntimeCompilationOptions>, CompilationOptionsSetup>());
Type mvcBuilderType = typeof(Builder);
PluginActivtor.LoadedPlugins.Add(new PluginDescriptor
{
Assembly = mvcBuilderType.Assembly,
PluginType = mvcBuilderType
});
builder.Services.UseZKEACMS(builder.Configuration, builder.Environment);
var app = builder.Build();
return(app);
}
public void WebApplicationBuilder_CanChangeSetWebRootPathsViaConfigureAppConfiguration()
{
var builder = WebApplication.CreateBuilder();
var webRootPath = "www";
var fullWebRootPath = Path.Combine(Directory.GetCurrentDirectory(), webRootPath);
builder.WebHost.ConfigureAppConfiguration(builder =>
{
builder.AddInMemoryCollection(new Dictionary <string, string>
{
{ WebHostDefaults.WebRootKey, webRootPath }
});
});
Assert.Equal(webRootPath, builder.WebHost.GetSetting("webroot"));
var app = builder.Build();
Assert.Equal(fullWebRootPath, app.Environment.WebRootPath);
}
public void WebApplicationBuilder_CanClearDefaultLoggers()
{
var listener = new TestEventListener();
var builder = WebApplication.CreateBuilder();
builder.Logging.ClearProviders();
var app = builder.Build();
var logger = app.Services.GetRequiredService <ILogger <WebApplicationTests> >();
var guid = Guid.NewGuid().ToString();
logger.LogInformation(guid);
var events = listener.EventData.ToArray();
Assert.DoesNotContain(events, args =>
args.EventSource.Name == "Microsoft-Extensions-Logging" &&
args.Payload.OfType <string>().Any(p => p.Contains(guid)));
}
public static async Task Main(string[] args)
{
var builder = WebApplication.CreateBuilder(args);
builder.WebHost
.ConfigureKestrel((context, options) =>
{
options.Listen(IPAddress.Any, 5001, listenOptions =>
{
// Use HTTP/3
listenOptions.Protocols = HttpProtocols.Http1AndHttp2AndHttp3;
listenOptions.UseHttps();
});
});
#endregion
await using var app = builder.Build();
app.MapGet("/", () => "Hello World!");
await app.RunAsync();
}
public void WebApplicationBuilder_CanSetWebRootPaths(bool useSetter)
{
var builder = WebApplication.CreateBuilder();
var webRootPath = "www";
var fullWebRootPath = Path.Combine(Directory.GetCurrentDirectory(), webRootPath);
if (useSetter)
{
builder.Environment.WebRootPath = webRootPath;
}
else
{
builder.WebHost.UseWebRoot(webRootPath);
Assert.Equal(webRootPath, builder.WebHost.GetSetting("webroot"));
}
var app = builder.Build();
Assert.Equal(fullWebRootPath, app.Environment.WebRootPath);
}
internal static async Task Main(string[] args)
{
var logger = LogManager.Setup().LoadConfigurationFromAppSettings().GetCurrentClassLogger();
logger.Debug($"init {nameof(Program.Main)}");
try
{
var webApiAssembly = System.Reflection.Assembly.GetExecutingAssembly();
var serviceInfo = Shared.WebApi.ServiceInfo.CreateInstance(webApiAssembly);
//Configuration,ServiceCollection,Logging,WebHost(Kestrel)
var app = WebApplication
.CreateBuilder(args)
.ConfigureAdncDefault(serviceInfo)
.Build();
//Middlewares
app.UseAdncDefault(endpointRoute: endpoint =>
{
endpoint.MapGrpcService <Grpc.AuthGrpcServer>();
endpoint.MapGrpcService <Grpc.UsrGrpcServer>();
});
//Start
await app
.ChangeThreadPoolSettings()
.UseRegistrationCenter()
.RunAsync();
}
catch (Exception ex)
{
logger.Error(ex, "Stopped program because of exception");
throw;
}
finally
{
// Ensure to flush and stop internal timers/threads before application-exit (Avoid segmentation fault on Linux)
LogManager.Shutdown();
}
}
public static void Main(string[] args)
{
var builder = WebApplication.CreateBuilder(args);
if (builder.Environment.IsDevelopment() == false)
{
var secretClient = new SecretClient(new Uri(builder.Configuration["KeyVaultUri"]), new DefaultAzureCredential());
builder.Configuration.AddAzureKeyVault(secretClient, new KeyVaultSecretManager());
}
// Add services to the container.
builder.Services.Configure <BlobSettings>(builder.Configuration.GetSection(nameof(BlobSettings)));
builder.Services.AddScoped <IBlobRepository, BlobRepository>();
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "WebServiceUnsafe", Version = "v1"
});
});
var app = builder.Build();
// Configure the HTTP request pipeline.
app.UseSwagger();
app.UseSwaggerUI(c => c.DisplayRequestDuration());
app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.Run();
}
public static void ServerCertificateSelector(string[] args)
{
// <snippet_ServerCertificateSelector>
var builder = WebApplication.CreateBuilder(args);
builder.WebHost.ConfigureKestrel(serverOptions =>
{
serverOptions.ListenAnyIP(5005, listenOptions =>
{
listenOptions.UseHttps(httpsOptions =>
{
var localhostCert = CertificateLoader.LoadFromStoreCert(
"localhost", "My", StoreLocation.CurrentUser,
allowInvalid: true);
var exampleCert = CertificateLoader.LoadFromStoreCert(
"example.com", "My", StoreLocation.CurrentUser,
allowInvalid: true);
var subExampleCert = CertificateLoader.LoadFromStoreCert(
"sub.example.com", "My", StoreLocation.CurrentUser,
allowInvalid: true);
var certs = new Dictionary <string, X509Certificate2>(
StringComparer.OrdinalIgnoreCase)
{
["localhost"] = localhostCert,
["example.com"] = exampleCert,
["sub.example.com"] = subExampleCert
};
httpsOptions.ServerCertificateSelector = (connectionContext, name) =>
{
if (name is not null && certs.TryGetValue(name, out var cert))
{
return(cert);
}
return(exampleCert);
};
});
});
});
static async Task Main(string[] args)
{
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDbContext <TodoDbContext>();
builder.Services.AddCors(options =>
{
options.AddDefaultPolicy(
cb => { cb.AllowAnyOrigin(); cb.AllowAnyMethod(); }
);
});
var app = builder.Build();
app.UseCors();
var todos = new TodoApi();
todos.MapRoutes(app);
await app.RunAsync();
}
/// <summary>
/// <para>
/// This constructor starts the server using a Unix domain socket at the
/// specified file system path. The server will run until disposed.
/// </para>
/// <note>
/// This service is currently exposed as HTTP, not HTTPS.
/// </note>
/// </summary>
/// <param name="socketPath">
/// Optionally overrides the path to the Unix domain socket path. This defaults to
/// <see cref="KubeHelper.WinDesktopServiceSocketPath"/> where <b>neon-desktop</b>
/// and <b>neon-cli</b> expect it to be.
/// </param>
/// <exception cref="GrpcServiceException">Thrown when the service could not be started.</exception>
public DesktopService(string socketPath = null)
{
this.socketPath = socketPath ??= KubeHelper.WinDesktopServiceSocketPath;
// Try to remove any existing socket file and if that fails we're
// going to assume that another service is already running on the
// socket.
try
{
if (File.Exists(socketPath))
{
File.Delete(socketPath);
}
}
catch (Exception e)
{
throw new GrpcServiceException($"Cannot start service using Unix socket at: {socketPath}", e);
}
var builder = WebApplication.CreateBuilder();
builder.Services.AddCodeFirstGrpc();
builder.WebHost.UseUrls();
builder.WebHost.UseKestrel(
options =>
{
options.ListenUnixSocket(socketPath, configure => configure.Protocols = HttpProtocols.Http2);
});
var app = builder.Build();
app.UseRouting();
app.UseEndpoints(endpoints => endpoints.MapGrpcService <GrpcDesktopService>());
cts = new CancellationTokenSource();
task = app.StartAsync(cts.Token);
}
public async Task WebApplicationBuilder_StartupFilterCanAddTerminalMiddleware()
{
var builder = WebApplication.CreateBuilder();
builder.WebHost.UseTestServer();
builder.Services.AddSingleton <IStartupFilter, TerminalMiddlewareStartupFilter>();
await using var app = builder.Build();
app.MapGet("/defined", () => { });
await app.StartAsync();
var client = app.GetTestClient();
var definedResult = await client.GetAsync("http://localhost/defined");
definedResult.EnsureSuccessStatusCode();
var terminalResult = await client.GetAsync("http://localhost/undefined");
Assert.Equal(418, (int)terminalResult.StatusCode);
}
public static void Main(string[] args)
{
var builder = WebApplication.CreateBuilder(args);
// Additional configuration is required to successfully run gRPC on macOS.
// For instructions on how to configure Kestrel and gRPC clients on macOS, visit https://go.microsoft.com/fwlink/?linkid=2099682
// Add services to the container.
builder.Services.AddGrpc();
builder.Services.AddGrpcReflection();
builder.Configuration.SetBasePath("/etc/ispindel/jobrunner")
.AddJsonFile("appsettings.json", optional: false)
.AddJsonFile($"appsettings.Production.json", optional: false);
builder.Services.Configure <MqttOptions>(builder.Configuration.GetSection(MqttOptions.MqttPosition));
builder.Services.Configure <SpindelServerOptions>(builder.Configuration.GetSection(SpindelServerOptions.SpindelServerPosition));
builder.Services.Configure <DbOptions>(builder.Configuration.GetSection(DbOptions.DbPosition));
builder.Services.Configure <GrpcServerOptions>(builder.Configuration.GetSection(GrpcServerOptions.GrpcServerPosition));
builder.Services.AddSingleton <IMqttClientFactory, MqttClientFactory>();
builder.Services.AddDbContextFactory <iSpindelContext>(options =>
{
options.UseNpgsql(builder.Configuration.GetConnectionString("DefaultConnection"));
});
//builder.Services.AddSingleton<IDbContextFactory, DbContextFactory>();
builder.Services.AddSingleton <ISpindelService, iSpindelServer>();
var app = builder.Build();
// Configure the HTTP request pipeline.
app.MapGrpcService <Services.RecordingService>();
if (builder.Environment.IsDevelopment())
{
app.MapGrpcReflectionService();
}
app.MapGet("/", () => "Communication with gRPC endpoints must be made through a gRPC client. To learn how to create a client, visit: https://go.microsoft.com/fwlink/?linkid=2086909");
app.Run();
}
static async Task Main(string[] args)
{
var builder = WebApplication.CreateBuilder(args);
builder.Configuration.AddYamlFile("appsettings.yml", optional: true);
builder.Host.UseSerilog((context, configuration)
=> configuration
.Enrich
.FromLogContext()
.WriteTo
.Console()
);
builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());
builder.Host.ConfigureContainer <ContainerBuilder>(b =>
{
// Register services using Autofac specific methods here
});
var app = builder.Build();
app.Listen("http://localhost:3000");
if (app.Environment.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseRouting();
app.MapGet("/", async context =>
{
await context.Response.WriteAsync("Hello World");
});
await app.RunAsync();
}
public async Task WebApplication_CanCallUseRoutingWithouUseEndpoints()
{
var builder = WebApplication.CreateBuilder();
builder.WebHost.UseTestServer();
await using var app = builder.Build();
app.MapGet("/new", () => "new");
// Rewrite "/old" to "/new" before matching routes
app.Use((context, next) =>
{
if (context.Request.Path == "/old")
{
context.Request.Path = "/new";
}
return(next(context));
});
app.UseRouting();
await app.StartAsync();
var endpointDataSource = app.Services.GetRequiredService <EndpointDataSource>();
var newEndpoint = Assert.Single(endpointDataSource.Endpoints);
var newRouteEndpoint = Assert.IsType <RouteEndpoint>(newEndpoint);
Assert.Equal("/new", newRouteEndpoint.RoutePattern.RawText);
var client = app.GetTestClient();
var oldResult = await client.GetAsync("http://localhost/old");
oldResult.EnsureSuccessStatusCode();
Assert.Equal("new", await oldResult.Content.ReadAsStringAsync());
}
private static void Start(string[] bindingUrls)
{
var(loggerProvider, logger) = CreateLoggers();
logger.LogInformation("Application starts");
var builder = WebApplication.CreateBuilder();
builder.Logging.ClearProviders();
builder.Logging.AddProvider(loggerProvider);
SetupServices(builder.Services);
if (bindingUrls?.Length > 0)
{
bindingUrls = bindingUrls.Where(x => !string.IsNullOrWhiteSpace(x)).ToArray();
logger.LogInformation($"Binding URLs: {string.Join(',', bindingUrls)}");
builder.WebHost.UseUrls(bindingUrls);
builder.WebHost.ConfigureKestrel(app =>
{
app.AllowSynchronousIO = true;
});
}
else
{
logger.LogWarning("No binding URLs were specified!");
}
var app = builder.Build();
_ = app.Environment.IsDevelopment()
? app.UseUnhandledExceptionHandler()
: app.UseDeveloperExceptionPage();
app.UseRequestLogger();
app.UseRequestPipeline();
app.Run();
}
public static void Main(string[] args)
{
// Load configs
LoadConfigsAsync();
// Create builder
var builder = WebApplication.CreateBuilder(args);
builder.Host.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseUrls("http://localhost:3000", "https://localhost:3001");
});
// Set up services
ConfigureServices(builder);
// Build web app
var app = builder.Build();
// Configure application
ConfigureApp(app);
app.MapGet("/api/ping", () => "pong");
// Add API routes
BaseAPI.AddRoutes(app);
UploadAPI.AddRoutes(app);
ChannelAPI.AddRoutes(app);
CategoryAPI.AddRoutes(app);
PlanetAPI.AddRoutes(app);
UserAPI.AddRoutes(app);
MemberAPI.AddRoutes(app);
RoleAPI.AddRoutes(app);
EmbedAPI.AddRoutes(app);
// Run
app.Run();
}
public async Task WebApplicationConfiguration_EnablesForwardedHeadersFromConfig()
{
var builder = WebApplication.CreateBuilder();
builder.WebHost.UseTestServer();
builder.Configuration["FORWARDEDHEADERS_ENABLED"] = "true";
await using var app = builder.Build();
app.Run(context =>
{
Assert.Equal("https", context.Request.Scheme);
return(Task.CompletedTask);
});
await app.StartAsync();
var client = app.GetTestClient();
client.DefaultRequestHeaders.Add("x-forwarded-proto", "https");
var result = await client.GetAsync("http://localhost/");
result.EnsureSuccessStatusCode();
}
