Files
mtusi2026lab5/src/Messenger.Api/Program.cs
T

132 lines
6.0 KiB
C#

using Messenger.Api.Pipeline;
using System.Text.Json;
using System.Text.Json.Serialization;
using Messenger.Api.Data;
using Messenger.Api.Endpoints;
using Messenger.Api.Infrastructure;
using Messenger.Api.Middleware;
using Messenger.Api.Services;
using Npgsql;
using StackExchange.Redis;
ThreadPool.GetMinThreads(out var workerThreads, out var completionThreads);
ThreadPool.SetMinThreads(Math.Max(8, workerThreads), completionThreads);
if(args.Length==3 && args[0]=="--render-image")
{
try {ImageRenderer.Render(args[1],args[2]);}
catch(InvalidDataException) {Environment.ExitCode=2;}
catch {Environment.ExitCode=3;}
return;
}
var builder = WebApplication.CreateBuilder(args);
if(args.Contains("--bootstrap"))
{
using var storage=new S3Storage(builder.Configuration);
try { await storage.Client.GetBucketLocationAsync(storage.Bucket); }
catch(Amazon.S3.AmazonS3Exception ex) when(ex.StatusCode==System.Net.HttpStatusCode.NotFound)
{ await storage.Client.PutBucketAsync(storage.Bucket); }
Console.WriteLine("Private bucket ready");
return;
}
var host = Environment.GetEnvironmentVariable("APP_HOST") ?? "0.0.0.0";
var port = Environment.GetEnvironmentVariable("APP_PORT") ?? "8080";
builder.WebHost.UseUrls($"http://{host}:{port}");
builder.Services.ConfigureHttpJsonOptions(options =>
{
options.SerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower;
options.SerializerOptions.UnmappedMemberHandling = JsonUnmappedMemberHandling.Disallow;
});
var databaseUrlFile = Environment.GetEnvironmentVariable("DATABASE_URL_FILE");
var databaseUrl = databaseUrlFile is not null
? File.ReadAllText(databaseUrlFile).Trim()
: Environment.GetEnvironmentVariable("DATABASE_URL");
if (string.IsNullOrWhiteSpace(databaseUrl))
throw new InvalidOperationException("Set DATABASE_URL_FILE or DATABASE_URL before starting the API");
var connectionString = new NpgsqlConnectionStringBuilder(databaseUrl)
{
MaxPoolSize = int.TryParse(builder.Configuration["DB_POOL_SIZE"], out var poolSize) && poolSize > 0 ? poolSize : 20,
Timeout = 5,
ApplicationName = "messenger-api",
CommandTimeout = 10
};
var dataSource = NpgsqlDataSource.Create(connectionString.ConnectionString);
if (args.Contains("--migrate", StringComparer.Ordinal))
{
await DatabaseMigrator.ApplyAsync(dataSource);
await dataSource.DisposeAsync();
return;
}
if(args.Contains("--worker") || args.Contains("--dispatcher") || args.Contains("--replay") || args.Contains("--redeliver") || args.Contains("--reconcile"))
{
using var storage=new S3Storage(builder.Configuration);
using var cancellation=new CancellationTokenSource();
Console.CancelKeyPress+=(_,e)=>{e.Cancel=true;cancellation.Cancel();};
using var signal=System.Runtime.InteropServices.PosixSignalRegistration.Create(System.Runtime.InteropServices.PosixSignal.SIGTERM,ctx=>{ctx.Cancel=true;cancellation.Cancel();});
var heartbeat=(args.Contains("--worker") || args.Contains("--dispatcher"))
? ProcessPresence.RunAsync(dataSource,args.Contains("--worker")?"worker":"dispatcher",cancellation.Token) : Task.CompletedTask;
try {
if(args.Contains("--worker"))await new PipelineWorker(dataSource,storage,builder.Configuration).RunAsync(cancellation.Token);
else if(args.Contains("--dispatcher"))await new OutboxDispatcher(dataSource,storage,builder.Configuration).RunAsync(cancellation.Token);
else if(args.Contains("--redeliver"))await JobOperations.RedeliverAsync(dataSource,builder.Configuration,Guid.Parse(args[Array.IndexOf(args,"--redeliver")+1]),cancellation.Token);
else if(args.Contains("--replay"))await new JobStore(dataSource,builder.Configuration).ReplayAsync(Guid.Parse(args[Array.IndexOf(args,"--replay")+1]),cancellation.Token);
else await new PipelineMaintenance(dataSource,storage,builder.Configuration).ReconcileStagingAsync(args.Contains("--apply"),cancellation.Token);
}catch(OperationCanceledException) when(cancellation.IsCancellationRequested) { }
cancellation.Cancel();await heartbeat;
await dataSource.DisposeAsync();return;
}
builder.Services.AddSingleton(dataSource);
builder.Services.AddSingleton<InstanceIdentity>();
builder.Services.AddSingleton<ReadinessState>();
builder.Services.Configure<HostOptions>(options => options.ShutdownTimeout = TimeSpan.FromSeconds(8));
builder.Services.AddSingleton<AppDatabase>();
builder.Services.AddSingleton<S3Storage>();
builder.Services.AddSingleton<AttachmentService>();
var redisOptions = ConfigurationOptions.Parse(builder.Configuration["REDIS_URL"] ?? "localhost:6379");
redisOptions.AbortOnConnectFail = false;
redisOptions.ConnectTimeout = 500;
redisOptions.ConnectRetry = 0;
redisOptions.AsyncTimeout = 500;
redisOptions.SyncTimeout = 500;
redisOptions.BacklogPolicy = BacklogPolicy.FailFast;
builder.Services.AddSingleton<IConnectionMultiplexer>(await ConnectionMultiplexer.ConnectAsync(redisOptions));
builder.Services.AddSingleton<RedisSessionCache>();
builder.Services.AddSingleton<PasswordService>();
builder.Services.AddSingleton<UserService>();
builder.Services.AddSingleton<SessionService>();
builder.Services.AddSingleton<ChatService>();
builder.Services.AddSingleton<MessageService>();
builder.Services.AddSingleton<ClusterPresence>();
builder.Services.AddHostedService(services => services.GetRequiredService<ClusterPresence>());
var app = builder.Build();
app.Lifetime.ApplicationStopping.Register(app.Services.GetRequiredService<ReadinessState>().Stop);
app.UseMiddleware<RequestIdMiddleware>();
app.UseMiddleware<InstanceMiddleware>();
app.UseMiddleware<RequestLoggingMiddleware>();
app.UseMiddleware<ExceptionHandlingMiddleware>();
app.UseDefaultFiles();
app.UseStaticFiles(new StaticFileOptions
{
OnPrepareResponse = context => context.Context.Response.Headers.CacheControl = "no-cache"
});
app.MapHealthEndpoints();
app.MapUserEndpoints();
app.MapAuthEndpoints();
app.MapChatEndpoints();
app.MapMessageEndpoints();
app.MapAttachmentEndpoints();
app.MapUiEndpoints();
app.MapOperationsEndpoints();
app.MapReactionEndpoints();
app.Run();