Remove mvc

src/SeqCli/Cli/Commands/Forwarder/RunCommand.cs

@@ -13,25 +13,30 @@
 // limitations under the License.
 
 using System;
+using System.Collections;
+using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Net;
 using System.Security.Cryptography.X509Certificates;
 using System.Threading.Tasks;
 using Autofac;
 using Autofac.Extensions.DependencyInjection;
+using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Hosting;
 using SeqCli.Cli.Features;
 using SeqCli.Config;
 using SeqCli.Config.Forwarder;
 using SeqCli.Forwarder;
 using SeqCli.Forwarder.Util;
+using SeqCli.Forwarder.Web.Api;
 using SeqCli.Forwarder.Web.Host;
 using Serilog;
 using Serilog.Core;
 using Serilog.Events;
 using Serilog.Formatting.Compact;
+using Serilog.Formatting.Display;
 
 #if WINDOWS
 using SeqCli.Forwarder.ServiceProcess;
@@ -97,57 +102,60 @@ protected override async Task<int> Run(string[] unrecognized)
         try
         {
             ILifetimeScope? container = null;
-            using var host = new HostBuilder()
-                .UseSerilog()
-                .UseServiceProviderFactory(new AutofacServiceProviderFactory())
-                .ConfigureContainer<ContainerBuilder>(builder =>
-                {
-                    builder.RegisterBuildCallback(ls => container = ls);
-                    builder.RegisterModule(new ForwarderModule(_storagePath.BufferPath, config));
-                })
-                .ConfigureWebHostDefaults(web =>
-                {
-                    web.UseStartup<Startup>();
-                    web.UseKestrel(options =>
-                        {
-                            options.AddServerHeader = false;
-                            options.AllowSynchronousIO = true;
-                        })
-                        .ConfigureKestrel(options =>
-                        {
-                            var apiListenUri = new Uri(listenUri);
+            var builder = WebApplication.CreateBuilder();
+            builder.WebHost.UseKestrel(options =>
+            {
+                options.AddServerHeader = false;
+                options.AllowSynchronousIO = true;
+            }).ConfigureKestrel((context, options) =>
+            {
+                var apiListenUri = new Uri(listenUri);
 
-                            var ipAddress = apiListenUri.HostNameType switch
-                            {
-                                UriHostNameType.Basic => IPAddress.Any,
-                                UriHostNameType.Dns => IPAddress.Any,
-                                UriHostNameType.IPv4 => IPAddress.Parse(apiListenUri.Host),
-                                UriHostNameType.IPv6 => IPAddress.Parse(apiListenUri.Host),
-                                _ => throw new NotSupportedException($"Listen URI type `{apiListenUri.HostNameType}` is not supported.")
-                            };
+                var ipAddress = apiListenUri.HostNameType switch
+                {
+                    UriHostNameType.Basic => IPAddress.Any,
+                    UriHostNameType.Dns => IPAddress.Any,
+                    UriHostNameType.IPv4 => IPAddress.Parse(apiListenUri.Host),
+                    UriHostNameType.IPv6 => IPAddress.Parse(apiListenUri.Host),
+                    _ => throw new NotSupportedException($"Listen URI type `{apiListenUri.HostNameType}` is not supported.")
+                };
 
-                            if (apiListenUri.Scheme.Equals("https", StringComparison.OrdinalIgnoreCase))
-                            {
-                                options.Listen(ipAddress, apiListenUri.Port, listenOptions =>
-                                {
+                if (apiListenUri.Scheme.Equals("https", StringComparison.OrdinalIgnoreCase))
+                {
+                    options.Listen(ipAddress, apiListenUri.Port, listenOptions =>
+                    {
 #if WINDOWS
                                     listenOptions.UseHttps(StoreName.My, apiListenUri.Host,
                                         location: StoreLocation.LocalMachine, allowInvalid: true);
 #else
-                                    listenOptions.UseHttps();
+                        listenOptions.UseHttps();
 #endif
-                                });
-                            }
-                            else
-                            {
-                                options.Listen(ipAddress, apiListenUri.Port);
-                            }
-                        });
-                })
-                .Build();
-
+                    });
+                }
+                else
+                {
+                    options.Listen(ipAddress, apiListenUri.Port);
+                }
+            });
+
+            builder
+                .Host.UseSerilog()
+                .UseServiceProviderFactory(new AutofacServiceProviderFactory())
+                .ConfigureContainer<ContainerBuilder>(builder =>
+                {
+                    builder.RegisterBuildCallback(ls => container = ls);
+                    builder.RegisterModule(new ForwarderModule(_storagePath.BufferPath, config));
+                });
+
+            using var host = builder.Build();
+
             if (container == null) throw new Exception("Host did not build container.");
-
+
+            foreach (var mapper in container.Resolve<IEnumerable<IMapEndpoints>>())
+            {
+                mapper.Map(host);
+            }
+
             var service = container.Resolve<ServerService>(
                 new TypedParameter(typeof(IHost), host),
                 new NamedParameter("listenUri", listenUri));

src/SeqCli/Cli/Features/StoragePathFeature.cs

@@ -1,6 +1,5 @@
 using System;
 using System.IO;
-using SeqCli.Forwarder.ServiceProcess;
 
 namespace SeqCli.Cli.Features;
 

src/SeqCli/Forwarder/ForwarderModule.cs

@@ -17,9 +17,10 @@
 using System.Threading;
 using Autofac;
 using SeqCli.Config;
-using SeqCli.Encryptor;
 using SeqCli.Forwarder.Multiplexing;
+using SeqCli.Forwarder.Web.Api;
 using SeqCli.Forwarder.Web.Host;
+using Serilog.Formatting.Display;
 
 namespace SeqCli.Forwarder;
 
@@ -43,6 +44,13 @@ protected override void Load(ContainerBuilder builder)
 
         builder.RegisterType<HttpLogShipperFactory>().As<ILogShipperFactory>();
         builder.RegisterType<ServerResponseProxy>().SingleInstance();
+        builder.RegisterType<ApiRootEndpoints>().As<IMapEndpoints>();
+        builder.RegisterType<IngestionEndpoints>().As<IMapEndpoints>();
+        builder.Register(c => _config.Connection);
+        builder.RegisterInstance(new MessageTemplateTextFormatter(
+            "[{Timestamp:o} {Level:u3}] {Message}{NewLine}" + (_config.Forwarder.Diagnostics.IngestionLogShowDetail
+                ? ""
+                : "Client IP address: {ClientHostIP}{NewLine}First {StartToLog} characters of payload: {DocumentStart:l}{NewLine}{Exception}{NewLine}"))).SingleInstance();
 
         builder.Register(c =>
         {

src/SeqCli/Forwarder/Web/Api/ApiRootEndpoints.cs

@@ -0,0 +1,52 @@
+// Copyright Datalust Pty Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System.IO;
+using System.Text;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using SeqCli.Forwarder.Diagnostics;
+using Serilog.Formatting.Display;
+
+namespace SeqCli.Forwarder.Web.Api;
+
+class ApiRootEndpoints : IMapEndpoints
+{
+    readonly MessageTemplateTextFormatter _formatter;
+    readonly Encoding Utf8 = new UTF8Encoding(false);
+
+    public ApiRootEndpoints(MessageTemplateTextFormatter formatter)
+    {
+        _formatter = formatter;
+    }
+
+    public void Map(WebApplication app)
+    {
+        app.MapGet("/", () =>
+        {
+            var events = IngestionLog.Read();
+            using var log = new StringWriter();
+            foreach (var logEvent in events)
+            {
+                _formatter.Format(logEvent, log);
+            }
+
+            return Results.Content(log.ToString(), "text/plain", Utf8);
+        });
+
+        app.MapGet("/api",
+            () => Results.Content("{\"Links\":{\"Events\":\"/api/events/describe\"}}", "application/json", Utf8));
+
+    }
+}

src/SeqCli/Forwarder/Web/Api/IMapEndpoints.cs

@@ -0,0 +1,8 @@
+using Microsoft.AspNetCore.Builder;
+
+namespace SeqCli.Forwarder.Web.Api;
+
+interface IMapEndpoints
+{
+    void Map(WebApplication app);
+}