Rename FowardingChannelWrapper to ForwardingAuthenticationStrategy, since its primary purpose is to switch between transparent API key forwarding and shared-connection use

Author: nblumhardt

README.md

@@ -15,8 +15,8 @@ dotnet tool install --global seqcli
 To set a default server URL and API key, run:
 
 ```
-seqcli config -k connection.serverUrl -v https://your-seq-server
-seqcli config -k connection.apiKey -v your-api-key
+seqcli config set -k connection.serverUrl -v https://your-seq-server
+seqcli config set -k connection.apiKey -v your-api-key
 ```
 
 The API key will be stored in your `SeqCli.json` configuration file; on Windows, this is encrypted using DPAPI; on Mac/Linux the key is stored in plain text unless an encryptor is defined in `encryption.encryptor`. As an alternative to storing the API key in configuration, it can be passed to each command via the `--apikey=` argument.

src/SeqCli/Forwarder/Channel/ApiKeyForwardingChannelWrapper.cs

@@ -1,3 +1,18 @@
+// 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;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
@@ -9,13 +24,12 @@
 
 namespace SeqCli.Forwarder.Channel;
 
-internal abstract class ForwardingChannelWrapper(string bufferPath, SeqConnection connection, SeqCliConfig config)
+abstract class ForwardingAuthenticationStrategy(string bufferPath, SeqConnection connection, SeqCliConfig config)
 {
-    protected const string SeqCliConnectionChannelId = "SeqCliConnection";
+    readonly CancellationTokenSource _shutdownTokenSource = new();
+
     protected readonly string BufferPath = bufferPath;
     protected readonly SeqCliConfig Config = config;
-    protected readonly CancellationTokenSource ShutdownTokenSource = new();
-    protected readonly Lock ChannelsSync = new();
 
     // <param name="id">The id used for the channel storage on the file system.</param>
     // <param name="apiKey">The apiKey that will be used to connect to the downstream Seq instance.</param>
@@ -24,7 +38,7 @@ protected ForwardingChannel OpenOrCreateChannel(string id, string? apiKey)
         var storePath = GetStorePath(id);
         var store = new SystemStoreDirectory(storePath);
 
-        Log.ForContext<ForwardingChannelWrapper>().Information("Opening local buffer in {StorePath}", storePath);
+        Log.ForContext<ForwardingAuthenticationStrategy>().Information("Opening local buffer in {StorePath}", storePath);
 
         return new ForwardingChannel(
             BufferAppender.Open(store),
@@ -35,15 +49,25 @@ protected ForwardingChannel OpenOrCreateChannel(string id, string? apiKey)
             Config.Forwarder.Storage.TargetChunkSizeBytes,
             Config.Forwarder.Storage.MaxChunks,
             Config.Connection.BatchSizeLimitBytes,
-            ShutdownTokenSource.Token);
+            _shutdownTokenSource.Token);
     }
 
     public abstract ForwardingChannel GetForwardingChannel(string? requestApiKey);
 
     public abstract Task StopAsync();
 
+    protected async Task OnStoppedAsync()
+    {
+        await _shutdownTokenSource.CancelAsync();
+    }
+
+    protected void OnStopping()
+    {
+        _shutdownTokenSource.CancelAfter(TimeSpan.FromSeconds(30));
+    }
+
     protected string GetStorePath(string id)
     {
         return Path.Combine(BufferPath, id);
     }
-}
+}

…rder/Channel/ForwardingChannelWrapper.cs …nnel/ForwardingAuthenticationStrategy.cssrc/SeqCli/Forwarder/Channel/ForwardingChannelWrapper.cs renamed to src/SeqCli/Forwarder/Channel/ForwardingAuthenticationStrategy.cs src/SeqCli/Forwarder/Channel/ForwardingChannelWrapper.cs renamed to src/SeqCli/Forwarder/Channel/ForwardingAuthenticationStrategy.cs

@@ -1,3 +1,17 @@
+// 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;
 using System.IO;
 using System.Threading;

src/SeqCli/Forwarder/Channel/ForwardingChannel.cs

@@ -1,3 +1,17 @@
+// 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;
 using System.Threading.Tasks;
 

src/SeqCli/Forwarder/Channel/ForwardingChannelEntry.cs

@@ -0,0 +1,46 @@
+// 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.Threading.Tasks;
+using Seq.Api;
+using SeqCli.Config;
+using Serilog;
+
+namespace SeqCli.Forwarder.Channel;
+
+class SharedConnectionForwardingAuthenticationStrategy: ForwardingAuthenticationStrategy
+{
+    public const string ChannelId = "SharedConnection";
+
+    readonly ForwardingChannel _sharedForwardingChannel;
+    
+    public SharedConnectionForwardingAuthenticationStrategy(string bufferPath, SeqConnection connection, SeqCliConfig config, string? seqCliApiKey): base(bufferPath, connection, config)
+    {
+        _sharedForwardingChannel = OpenOrCreateChannel(ChannelId, seqCliApiKey);
+    }
+    
+    public override ForwardingChannel GetForwardingChannel(string? _)
+    {
+        return _sharedForwardingChannel;
+    }
+    
+    public override async Task StopAsync()
+    {
+        Log.ForContext<SharedConnectionForwardingAuthenticationStrategy>().Information("Flushing log buffer");
+        OnStopping();
+
+        await _sharedForwardingChannel.StopAsync();
+        await OnStoppedAsync(); 
+    }
+}

src/SeqCli/Forwarder/Channel/SeqCliConnectionForwardingChannelWrapper.cs

@@ -0,0 +1,105 @@
+// 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;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Seq.Api;
+using SeqCli.Config;
+using SeqCli.Forwarder.Filesystem.System;
+using Serilog;
+
+namespace SeqCli.Forwarder.Channel;
+
+class TransparentForwardingAuthenticationStrategy : ForwardingAuthenticationStrategy
+{
+    readonly Lock _channelsSync = new();
+    readonly Dictionary<string, ForwardingChannel> _channelsByApiKey = new();
+    const string EmptyApiKeyChannelId = "EmptyApiKey";
+
+    public TransparentForwardingAuthenticationStrategy(string bufferPath, SeqConnection connection, SeqCliConfig config) : base(bufferPath, connection, config)
+    {
+        LoadChannels();
+    }
+    
+    // Start forwarding channels found on the file system.
+    void LoadChannels()
+    {
+        foreach (var directoryPath in Directory.EnumerateDirectories(BufferPath))
+        {
+            if (directoryPath.Equals(GetStorePath(SharedConnectionForwardingAuthenticationStrategy.ChannelId)))
+            {
+                Log.ForContext<TransparentForwardingAuthenticationStrategy>().Information(
+                    "Ignoring data stored in `{DirectoryPath}` prior to API key forwarding being enabled", directoryPath);
+                continue;
+            }
+
+            string apiKey, channelId;
+
+            if (new SystemStoreDirectory(directoryPath).TryReadApiKey(Config, out var key))
+            {
+                apiKey = key;
+                channelId = directoryPath;
+            }
+            else
+            {
+                Log.ForContext<TransparentForwardingAuthenticationStrategy>().Information(
+                    "Directory `{DirectoryPath}` does not contain a readable API key and will be ignored", directoryPath);
+                continue;
+            }
+            
+            var created = OpenOrCreateChannel(channelId, apiKey);
+            _channelsByApiKey.Add(apiKey, created);
+        }
+    }
+
+    public override ForwardingChannel GetForwardingChannel(string? requestApiKey)
+    {
+        // Use an empty string to represent no api key, since `_channelsByApiKey` does not allow null keys.
+        requestApiKey = string.IsNullOrWhiteSpace(requestApiKey) ? "" : requestApiKey;
+
+        lock (_channelsSync)
+        {
+            if (_channelsByApiKey.TryGetValue(requestApiKey, out var channel))
+            {
+                return channel;
+            }
+
+            var channelId = requestApiKey == "" ? EmptyApiKeyChannelId : Guid.NewGuid().ToString("n");
+            var created = OpenOrCreateChannel(channelId, requestApiKey);
+            var store = new SystemStoreDirectory(GetStorePath(channelId));
+            store.WriteApiKey(Config, requestApiKey);
+            _channelsByApiKey.Add(requestApiKey, created);
+            return created;
+        }
+    }
+
+    public override async Task StopAsync()
+    {
+        Log.ForContext<TransparentForwardingAuthenticationStrategy>().Information("Flushing log buffers");
+        OnStopping();
+
+        Task[] stopChannels;
+        lock (_channelsSync)
+        {
+            stopChannels = _channelsByApiKey.Values.Select(ch => ch.StopAsync()).ToArray();
+        }
+        
+        await Task.WhenAll(stopChannels);
+        await OnStoppedAsync();
+    }
+}