Revert filescoped (#2227)

* Revert "Add git blame entry (#2226)"

This reverts commit 239286737d.

* Revert "Turn on file scoped namespaces (#2225)"

This reverts commit 34fb4cca2a.

src/Admin/HostedServices/AmazonSqsBlockIpHostedService.cs

@@ -4,80 +4,81 @@ using Amazon.SQS.Model;
 using Bit.Core.Settings;
 using Microsoft.Extensions.Options;
 
-namespace Bit.Admin.HostedServices;
-
-public class AmazonSqsBlockIpHostedService : BlockIpHostedService
+namespace Bit.Admin.HostedServices
 {
-    private AmazonSQSClient _client;
-
-    public AmazonSqsBlockIpHostedService(
-        ILogger<AmazonSqsBlockIpHostedService> logger,
-        IOptions<AdminSettings> adminSettings,
-        GlobalSettings globalSettings)
-        : base(logger, adminSettings, globalSettings)
-    { }
-
-    public override void Dispose()
+    public class AmazonSqsBlockIpHostedService : BlockIpHostedService
     {
-        _client?.Dispose();
-    }
+        private AmazonSQSClient _client;
 
-    protected override async Task ExecuteAsync(CancellationToken cancellationToken)
-    {
-        _client = new AmazonSQSClient(_globalSettings.Amazon.AccessKeyId,
-            _globalSettings.Amazon.AccessKeySecret, RegionEndpoint.GetBySystemName(_globalSettings.Amazon.Region));
-        var blockIpQueue = await _client.GetQueueUrlAsync("block-ip", cancellationToken);
-        var blockIpQueueUrl = blockIpQueue.QueueUrl;
-        var unblockIpQueue = await _client.GetQueueUrlAsync("unblock-ip", cancellationToken);
-        var unblockIpQueueUrl = unblockIpQueue.QueueUrl;
+        public AmazonSqsBlockIpHostedService(
+            ILogger<AmazonSqsBlockIpHostedService> logger,
+            IOptions<AdminSettings> adminSettings,
+            GlobalSettings globalSettings)
+            : base(logger, adminSettings, globalSettings)
+        { }
 
-        while (!cancellationToken.IsCancellationRequested)
+        public override void Dispose()
         {
-            var blockMessageResponse = await _client.ReceiveMessageAsync(new ReceiveMessageRequest
-            {
-                QueueUrl = blockIpQueueUrl,
-                MaxNumberOfMessages = 10,
-                WaitTimeSeconds = 15
-            }, cancellationToken);
-            if (blockMessageResponse.Messages.Any())
-            {
-                foreach (var message in blockMessageResponse.Messages)
-                {
-                    try
-                    {
-                        await BlockIpAsync(message.Body, cancellationToken);
-                    }
-                    catch (Exception e)
-                    {
-                        _logger.LogError(e, "Failed to block IP.");
-                    }
-                    await _client.DeleteMessageAsync(blockIpQueueUrl, message.ReceiptHandle, cancellationToken);
-                }
-            }
+            _client?.Dispose();
+        }
 
-            var unblockMessageResponse = await _client.ReceiveMessageAsync(new ReceiveMessageRequest
-            {
-                QueueUrl = unblockIpQueueUrl,
-                MaxNumberOfMessages = 10,
-                WaitTimeSeconds = 15
-            }, cancellationToken);
-            if (unblockMessageResponse.Messages.Any())
-            {
-                foreach (var message in unblockMessageResponse.Messages)
-                {
-                    try
-                    {
-                        await UnblockIpAsync(message.Body, cancellationToken);
-                    }
-                    catch (Exception e)
-                    {
-                        _logger.LogError(e, "Failed to unblock IP.");
-                    }
-                    await _client.DeleteMessageAsync(unblockIpQueueUrl, message.ReceiptHandle, cancellationToken);
-                }
-            }
+        protected override async Task ExecuteAsync(CancellationToken cancellationToken)
+        {
+            _client = new AmazonSQSClient(_globalSettings.Amazon.AccessKeyId,
+                _globalSettings.Amazon.AccessKeySecret, RegionEndpoint.GetBySystemName(_globalSettings.Amazon.Region));
+            var blockIpQueue = await _client.GetQueueUrlAsync("block-ip", cancellationToken);
+            var blockIpQueueUrl = blockIpQueue.QueueUrl;
+            var unblockIpQueue = await _client.GetQueueUrlAsync("unblock-ip", cancellationToken);
+            var unblockIpQueueUrl = unblockIpQueue.QueueUrl;
 
-            await Task.Delay(TimeSpan.FromSeconds(15));
+            while (!cancellationToken.IsCancellationRequested)
+            {
+                var blockMessageResponse = await _client.ReceiveMessageAsync(new ReceiveMessageRequest
+                {
+                    QueueUrl = blockIpQueueUrl,
+                    MaxNumberOfMessages = 10,
+                    WaitTimeSeconds = 15
+                }, cancellationToken);
+                if (blockMessageResponse.Messages.Any())
+                {
+                    foreach (var message in blockMessageResponse.Messages)
+                    {
+                        try
+                        {
+                            await BlockIpAsync(message.Body, cancellationToken);
+                        }
+                        catch (Exception e)
+                        {
+                            _logger.LogError(e, "Failed to block IP.");
+                        }
+                        await _client.DeleteMessageAsync(blockIpQueueUrl, message.ReceiptHandle, cancellationToken);
+                    }
+                }
+
+                var unblockMessageResponse = await _client.ReceiveMessageAsync(new ReceiveMessageRequest
+                {
+                    QueueUrl = unblockIpQueueUrl,
+                    MaxNumberOfMessages = 10,
+                    WaitTimeSeconds = 15
+                }, cancellationToken);
+                if (unblockMessageResponse.Messages.Any())
+                {
+                    foreach (var message in unblockMessageResponse.Messages)
+                    {
+                        try
+                        {
+                            await UnblockIpAsync(message.Body, cancellationToken);
+                        }
+                        catch (Exception e)
+                        {
+                            _logger.LogError(e, "Failed to unblock IP.");
+                        }
+                        await _client.DeleteMessageAsync(unblockIpQueueUrl, message.ReceiptHandle, cancellationToken);
+                    }
+                }
+
+                await Task.Delay(TimeSpan.FromSeconds(15));
+            }
         }
     }
 }

src/Admin/HostedServices/AzureQueueBlockIpHostedService.cs

@@ -2,62 +2,63 @@
 using Bit.Core.Settings;
 using Microsoft.Extensions.Options;
 
-namespace Bit.Admin.HostedServices;
-
-public class AzureQueueBlockIpHostedService : BlockIpHostedService
+namespace Bit.Admin.HostedServices
 {
-    private QueueClient _blockIpQueueClient;
-    private QueueClient _unblockIpQueueClient;
-
-    public AzureQueueBlockIpHostedService(
-        ILogger<AzureQueueBlockIpHostedService> logger,
-        IOptions<AdminSettings> adminSettings,
-        GlobalSettings globalSettings)
-        : base(logger, adminSettings, globalSettings)
-    { }
-
-    protected override async Task ExecuteAsync(CancellationToken cancellationToken)
+    public class AzureQueueBlockIpHostedService : BlockIpHostedService
     {
-        _blockIpQueueClient = new QueueClient(_globalSettings.Storage.ConnectionString, "blockip");
-        _unblockIpQueueClient = new QueueClient(_globalSettings.Storage.ConnectionString, "unblockip");
+        private QueueClient _blockIpQueueClient;
+        private QueueClient _unblockIpQueueClient;
 
-        while (!cancellationToken.IsCancellationRequested)
+        public AzureQueueBlockIpHostedService(
+            ILogger<AzureQueueBlockIpHostedService> logger,
+            IOptions<AdminSettings> adminSettings,
+            GlobalSettings globalSettings)
+            : base(logger, adminSettings, globalSettings)
+        { }
+
+        protected override async Task ExecuteAsync(CancellationToken cancellationToken)
         {
-            var blockMessages = await _blockIpQueueClient.ReceiveMessagesAsync(maxMessages: 32);
-            if (blockMessages.Value?.Any() ?? false)
-            {
-                foreach (var message in blockMessages.Value)
-                {
-                    try
-                    {
-                        await BlockIpAsync(message.MessageText, cancellationToken);
-                    }
-                    catch (Exception e)
-                    {
-                        _logger.LogError(e, "Failed to block IP.");
-                    }
-                    await _blockIpQueueClient.DeleteMessageAsync(message.MessageId, message.PopReceipt);
-                }
-            }
+            _blockIpQueueClient = new QueueClient(_globalSettings.Storage.ConnectionString, "blockip");
+            _unblockIpQueueClient = new QueueClient(_globalSettings.Storage.ConnectionString, "unblockip");
 
-            var unblockMessages = await _unblockIpQueueClient.ReceiveMessagesAsync(maxMessages: 32);
-            if (unblockMessages.Value?.Any() ?? false)
+            while (!cancellationToken.IsCancellationRequested)
             {
-                foreach (var message in unblockMessages.Value)
+                var blockMessages = await _blockIpQueueClient.ReceiveMessagesAsync(maxMessages: 32);
+                if (blockMessages.Value?.Any() ?? false)
                 {
-                    try
+                    foreach (var message in blockMessages.Value)
                     {
-                        await UnblockIpAsync(message.MessageText, cancellationToken);
+                        try
+                        {
+                            await BlockIpAsync(message.MessageText, cancellationToken);
+                        }
+                        catch (Exception e)
+                        {
+                            _logger.LogError(e, "Failed to block IP.");
+                        }
+                        await _blockIpQueueClient.DeleteMessageAsync(message.MessageId, message.PopReceipt);
                     }
-                    catch (Exception e)
-                    {
-                        _logger.LogError(e, "Failed to unblock IP.");
-                    }
-                    await _unblockIpQueueClient.DeleteMessageAsync(message.MessageId, message.PopReceipt);
                 }
-            }
 
-            await Task.Delay(TimeSpan.FromSeconds(15));
+                var unblockMessages = await _unblockIpQueueClient.ReceiveMessagesAsync(maxMessages: 32);
+                if (unblockMessages.Value?.Any() ?? false)
+                {
+                    foreach (var message in unblockMessages.Value)
+                    {
+                        try
+                        {
+                            await UnblockIpAsync(message.MessageText, cancellationToken);
+                        }
+                        catch (Exception e)
+                        {
+                            _logger.LogError(e, "Failed to unblock IP.");
+                        }
+                        await _unblockIpQueueClient.DeleteMessageAsync(message.MessageId, message.PopReceipt);
+                    }
+                }
+
+                await Task.Delay(TimeSpan.FromSeconds(15));
+            }
         }
     }
 }

src/Admin/HostedServices/AzureQueueMailHostedService.cs

@@ -6,96 +6,97 @@ using Bit.Core.Services;
 using Bit.Core.Settings;
 using Bit.Core.Utilities;
 
-namespace Bit.Admin.HostedServices;
-
-public class AzureQueueMailHostedService : IHostedService
+namespace Bit.Admin.HostedServices
 {
-    private readonly ILogger<AzureQueueMailHostedService> _logger;
-    private readonly GlobalSettings _globalSettings;
-    private readonly IMailService _mailService;
-    private CancellationTokenSource _cts;
-    private Task _executingTask;
-
-    private QueueClient _mailQueueClient;
-
-    public AzureQueueMailHostedService(
-        ILogger<AzureQueueMailHostedService> logger,
-        IMailService mailService,
-        GlobalSettings globalSettings)
+    public class AzureQueueMailHostedService : IHostedService
     {
-        _logger = logger;
-        _mailService = mailService;
-        _globalSettings = globalSettings;
-    }
+        private readonly ILogger<AzureQueueMailHostedService> _logger;
+        private readonly GlobalSettings _globalSettings;
+        private readonly IMailService _mailService;
+        private CancellationTokenSource _cts;
+        private Task _executingTask;
 
-    public Task StartAsync(CancellationToken cancellationToken)
-    {
-        _cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
-        _executingTask = ExecuteAsync(_cts.Token);
-        return _executingTask.IsCompleted ? _executingTask : Task.CompletedTask;
-    }
+        private QueueClient _mailQueueClient;
 
-    public async Task StopAsync(CancellationToken cancellationToken)
-    {
-        if (_executingTask == null)
+        public AzureQueueMailHostedService(
+            ILogger<AzureQueueMailHostedService> logger,
+            IMailService mailService,
+            GlobalSettings globalSettings)
         {
-            return;
+            _logger = logger;
+            _mailService = mailService;
+            _globalSettings = globalSettings;
         }
-        _cts.Cancel();
-        await Task.WhenAny(_executingTask, Task.Delay(-1, cancellationToken));
-        cancellationToken.ThrowIfCancellationRequested();
-    }
 
-    private async Task ExecuteAsync(CancellationToken cancellationToken)
-    {
-        _mailQueueClient = new QueueClient(_globalSettings.Mail.ConnectionString, "mail");
-
-        QueueMessage[] mailMessages;
-        while (!cancellationToken.IsCancellationRequested)
+        public Task StartAsync(CancellationToken cancellationToken)
         {
-            if (!(mailMessages = await RetrieveMessagesAsync()).Any())
+            _cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+            _executingTask = ExecuteAsync(_cts.Token);
+            return _executingTask.IsCompleted ? _executingTask : Task.CompletedTask;
+        }
+
+        public async Task StopAsync(CancellationToken cancellationToken)
+        {
+            if (_executingTask == null)
             {
-                await Task.Delay(TimeSpan.FromSeconds(15));
+                return;
             }
+            _cts.Cancel();
+            await Task.WhenAny(_executingTask, Task.Delay(-1, cancellationToken));
+            cancellationToken.ThrowIfCancellationRequested();
+        }
 
-            foreach (var message in mailMessages)
+        private async Task ExecuteAsync(CancellationToken cancellationToken)
+        {
+            _mailQueueClient = new QueueClient(_globalSettings.Mail.ConnectionString, "mail");
+
+            QueueMessage[] mailMessages;
+            while (!cancellationToken.IsCancellationRequested)
             {
-                try
+                if (!(mailMessages = await RetrieveMessagesAsync()).Any())
                 {
-                    using var document = JsonDocument.Parse(message.DecodeMessageText());
-                    var root = document.RootElement;
+                    await Task.Delay(TimeSpan.FromSeconds(15));
+                }
 
-                    if (root.ValueKind == JsonValueKind.Array)
+                foreach (var message in mailMessages)
+                {
+                    try
                     {
-                        foreach (var mailQueueMessage in root.ToObject<List<MailQueueMessage>>())
+                        using var document = JsonDocument.Parse(message.DecodeMessageText());
+                        var root = document.RootElement;
+
+                        if (root.ValueKind == JsonValueKind.Array)
                         {
+                            foreach (var mailQueueMessage in root.ToObject<List<MailQueueMessage>>())
+                            {
+                                await _mailService.SendEnqueuedMailMessageAsync(mailQueueMessage);
+                            }
+                        }
+                        else if (root.ValueKind == JsonValueKind.Object)
+                        {
+                            var mailQueueMessage = root.ToObject<MailQueueMessage>();
                             await _mailService.SendEnqueuedMailMessageAsync(mailQueueMessage);
                         }
                     }
-                    else if (root.ValueKind == JsonValueKind.Object)
+                    catch (Exception e)
                     {
-                        var mailQueueMessage = root.ToObject<MailQueueMessage>();
-                        await _mailService.SendEnqueuedMailMessageAsync(mailQueueMessage);
+                        _logger.LogError(e, "Failed to send email");
+                        // TODO: retries?
                     }
-                }
-                catch (Exception e)
-                {
-                    _logger.LogError(e, "Failed to send email");
-                    // TODO: retries?
-                }
 
-                await _mailQueueClient.DeleteMessageAsync(message.MessageId, message.PopReceipt);
+                    await _mailQueueClient.DeleteMessageAsync(message.MessageId, message.PopReceipt);
 
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    break;
+                    if (cancellationToken.IsCancellationRequested)
+                    {
+                        break;
+                    }
                 }
             }
         }
-    }
 
-    private async Task<QueueMessage[]> RetrieveMessagesAsync()
-    {
-        return (await _mailQueueClient.ReceiveMessagesAsync(maxMessages: 32))?.Value ?? new QueueMessage[] { };
+        private async Task<QueueMessage[]> RetrieveMessagesAsync()
+        {
+            return (await _mailQueueClient.ReceiveMessagesAsync(maxMessages: 32))?.Value ?? new QueueMessage[] { };
+        }
     }
 }

src/Admin/HostedServices/BlockIpHostedService.cs

@@ -1,105 +1,71 @@
 using Bit.Core.Settings;
 using Microsoft.Extensions.Options;
 
-namespace Bit.Admin.HostedServices;
-
-public abstract class BlockIpHostedService : IHostedService, IDisposable
+namespace Bit.Admin.HostedServices
 {
-    protected readonly ILogger<BlockIpHostedService> _logger;
-    protected readonly GlobalSettings _globalSettings;
-    private readonly AdminSettings _adminSettings;
-
-    private Task _executingTask;
-    private CancellationTokenSource _cts;
-    private HttpClient _httpClient = new HttpClient();
-
-    public BlockIpHostedService(
-        ILogger<BlockIpHostedService> logger,
-        IOptions<AdminSettings> adminSettings,
-        GlobalSettings globalSettings)
+    public abstract class BlockIpHostedService : IHostedService, IDisposable
     {
-        _logger = logger;
-        _globalSettings = globalSettings;
-        _adminSettings = adminSettings?.Value;
-    }
+        protected readonly ILogger<BlockIpHostedService> _logger;
+        protected readonly GlobalSettings _globalSettings;
+        private readonly AdminSettings _adminSettings;
 
-    public Task StartAsync(CancellationToken cancellationToken)
-    {
-        _cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
-        _executingTask = ExecuteAsync(_cts.Token);
-        return _executingTask.IsCompleted ? _executingTask : Task.CompletedTask;
-    }
+        private Task _executingTask;
+        private CancellationTokenSource _cts;
+        private HttpClient _httpClient = new HttpClient();
 
-    public async Task StopAsync(CancellationToken cancellationToken)
-    {
-        if (_executingTask == null)
+        public BlockIpHostedService(
+            ILogger<BlockIpHostedService> logger,
+            IOptions<AdminSettings> adminSettings,
+            GlobalSettings globalSettings)
         {
-            return;
+            _logger = logger;
+            _globalSettings = globalSettings;
+            _adminSettings = adminSettings?.Value;
         }
-        _cts.Cancel();
-        await Task.WhenAny(_executingTask, Task.Delay(-1, cancellationToken));
-        cancellationToken.ThrowIfCancellationRequested();
-    }
 
-    public virtual void Dispose()
-    { }
-
-    protected abstract Task ExecuteAsync(CancellationToken cancellationToken);
-
-    protected async Task BlockIpAsync(string message, CancellationToken cancellationToken)
-    {
-        var request = new HttpRequestMessage();
-        request.Headers.Accept.Clear();
-        request.Headers.Add("X-Auth-Email", _adminSettings.Cloudflare.AuthEmail);
-        request.Headers.Add("X-Auth-Key", _adminSettings.Cloudflare.AuthKey);
-        request.Method = HttpMethod.Post;
-        request.RequestUri = new Uri("https://api.cloudflare.com/" +
-            $"client/v4/zones/{_adminSettings.Cloudflare.ZoneId}/firewall/access_rules/rules");
-
-        request.Content = JsonContent.Create(new
+        public Task StartAsync(CancellationToken cancellationToken)
         {
-            mode = "block",
-            configuration = new
+            _cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+            _executingTask = ExecuteAsync(_cts.Token);
+            return _executingTask.IsCompleted ? _executingTask : Task.CompletedTask;
+        }
+
+        public async Task StopAsync(CancellationToken cancellationToken)
+        {
+            if (_executingTask == null)
             {
-                target = "ip",
-                value = message
-            },
-            notes = $"Rate limit abuse on {DateTime.UtcNow.ToString()}."
-        });
-
-        var response = await _httpClient.SendAsync(request, cancellationToken);
-        if (!response.IsSuccessStatusCode)
-        {
-            return;
+                return;
+            }
+            _cts.Cancel();
+            await Task.WhenAny(_executingTask, Task.Delay(-1, cancellationToken));
+            cancellationToken.ThrowIfCancellationRequested();
         }
 
-        var accessRuleResponse = await response.Content.ReadFromJsonAsync<AccessRuleResponse>(cancellationToken: cancellationToken);
-        if (!accessRuleResponse.Success)
-        {
-            return;
-        }
+        public virtual void Dispose()
+        { }
 
-        // TODO: Send `accessRuleResponse.Result?.Id` message to unblock queue
-    }
+        protected abstract Task ExecuteAsync(CancellationToken cancellationToken);
 
-    protected async Task UnblockIpAsync(string message, CancellationToken cancellationToken)
-    {
-        if (string.IsNullOrWhiteSpace(message))
+        protected async Task BlockIpAsync(string message, CancellationToken cancellationToken)
         {
-            return;
-        }
-
-        if (message.Contains(".") || message.Contains(":"))
-        {
-            // IP address messages
             var request = new HttpRequestMessage();
             request.Headers.Accept.Clear();
             request.Headers.Add("X-Auth-Email", _adminSettings.Cloudflare.AuthEmail);
             request.Headers.Add("X-Auth-Key", _adminSettings.Cloudflare.AuthKey);
-            request.Method = HttpMethod.Get;
+            request.Method = HttpMethod.Post;
             request.RequestUri = new Uri("https://api.cloudflare.com/" +
-                $"client/v4/zones/{_adminSettings.Cloudflare.ZoneId}/firewall/access_rules/rules?" +
-                $"configuration_target=ip&configuration_value={message}");
+                $"client/v4/zones/{_adminSettings.Cloudflare.ZoneId}/firewall/access_rules/rules");
+
+            request.Content = JsonContent.Create(new
+            {
+                mode = "block",
+                configuration = new
+                {
+                    target = "ip",
+                    value = message
+                },
+                notes = $"Rate limit abuse on {DateTime.UtcNow.ToString()}."
+            });
 
             var response = await _httpClient.SendAsync(request, cancellationToken);
             if (!response.IsSuccessStatusCode)
@@ -107,58 +73,93 @@ public abstract class BlockIpHostedService : IHostedService, IDisposable
                 return;
             }
 
-            var listResponse = await response.Content.ReadFromJsonAsync<ListResponse>(cancellationToken: cancellationToken);
-            if (!listResponse.Success)
+            var accessRuleResponse = await response.Content.ReadFromJsonAsync<AccessRuleResponse>(cancellationToken: cancellationToken);
+            if (!accessRuleResponse.Success)
             {
                 return;
             }
 
-            foreach (var rule in listResponse.Result)
+            // TODO: Send `accessRuleResponse.Result?.Id` message to unblock queue
+        }
+
+        protected async Task UnblockIpAsync(string message, CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrWhiteSpace(message))
             {
-                await DeleteAccessRuleAsync(rule.Id, cancellationToken);
+                return;
+            }
+
+            if (message.Contains(".") || message.Contains(":"))
+            {
+                // IP address messages
+                var request = new HttpRequestMessage();
+                request.Headers.Accept.Clear();
+                request.Headers.Add("X-Auth-Email", _adminSettings.Cloudflare.AuthEmail);
+                request.Headers.Add("X-Auth-Key", _adminSettings.Cloudflare.AuthKey);
+                request.Method = HttpMethod.Get;
+                request.RequestUri = new Uri("https://api.cloudflare.com/" +
+                    $"client/v4/zones/{_adminSettings.Cloudflare.ZoneId}/firewall/access_rules/rules?" +
+                    $"configuration_target=ip&configuration_value={message}");
+
+                var response = await _httpClient.SendAsync(request, cancellationToken);
+                if (!response.IsSuccessStatusCode)
+                {
+                    return;
+                }
+
+                var listResponse = await response.Content.ReadFromJsonAsync<ListResponse>(cancellationToken: cancellationToken);
+                if (!listResponse.Success)
+                {
+                    return;
+                }
+
+                foreach (var rule in listResponse.Result)
+                {
+                    await DeleteAccessRuleAsync(rule.Id, cancellationToken);
+                }
+            }
+            else
+            {
+                // Rule Id messages
+                await DeleteAccessRuleAsync(message, cancellationToken);
             }
         }
-        else
+
+        protected async Task DeleteAccessRuleAsync(string ruleId, CancellationToken cancellationToken)
         {
-            // Rule Id messages
-            await DeleteAccessRuleAsync(message, cancellationToken);
+            var request = new HttpRequestMessage();
+            request.Headers.Accept.Clear();
+            request.Headers.Add("X-Auth-Email", _adminSettings.Cloudflare.AuthEmail);
+            request.Headers.Add("X-Auth-Key", _adminSettings.Cloudflare.AuthKey);
+            request.Method = HttpMethod.Delete;
+            request.RequestUri = new Uri("https://api.cloudflare.com/" +
+                $"client/v4/zones/{_adminSettings.Cloudflare.ZoneId}/firewall/access_rules/rules/{ruleId}");
+            await _httpClient.SendAsync(request, cancellationToken);
         }
-    }
 
-    protected async Task DeleteAccessRuleAsync(string ruleId, CancellationToken cancellationToken)
-    {
-        var request = new HttpRequestMessage();
-        request.Headers.Accept.Clear();
-        request.Headers.Add("X-Auth-Email", _adminSettings.Cloudflare.AuthEmail);
-        request.Headers.Add("X-Auth-Key", _adminSettings.Cloudflare.AuthKey);
-        request.Method = HttpMethod.Delete;
-        request.RequestUri = new Uri("https://api.cloudflare.com/" +
-            $"client/v4/zones/{_adminSettings.Cloudflare.ZoneId}/firewall/access_rules/rules/{ruleId}");
-        await _httpClient.SendAsync(request, cancellationToken);
-    }
-
-    public class ListResponse
-    {
-        public bool Success { get; set; }
-        public List<AccessRuleResultResponse> Result { get; set; }
-    }
-
-    public class AccessRuleResponse
-    {
-        public bool Success { get; set; }
-        public AccessRuleResultResponse Result { get; set; }
-    }
-
-    public class AccessRuleResultResponse
-    {
-        public string Id { get; set; }
-        public string Notes { get; set; }
-        public ConfigurationResponse Configuration { get; set; }
-
-        public class ConfigurationResponse
+        public class ListResponse
         {
-            public string Target { get; set; }
-            public string Value { get; set; }
+            public bool Success { get; set; }
+            public List<AccessRuleResultResponse> Result { get; set; }
+        }
+
+        public class AccessRuleResponse
+        {
+            public bool Success { get; set; }
+            public AccessRuleResultResponse Result { get; set; }
+        }
+
+        public class AccessRuleResultResponse
+        {
+            public string Id { get; set; }
+            public string Notes { get; set; }
+            public ConfigurationResponse Configuration { get; set; }
+
+            public class ConfigurationResponse
+            {
+                public string Target { get; set; }
+                public string Value { get; set; }
+            }
         }
     }
 }

src/Admin/HostedServices/DatabaseMigrationHostedService.cs

@@ -3,61 +3,62 @@ using Bit.Core.Jobs;
 using Bit.Core.Settings;
 using Bit.Migrator;
 
-namespace Bit.Admin.HostedServices;
-
-public class DatabaseMigrationHostedService : IHostedService, IDisposable
+namespace Bit.Admin.HostedServices
 {
-    private readonly GlobalSettings _globalSettings;
-    private readonly ILogger<DatabaseMigrationHostedService> _logger;
-    private readonly DbMigrator _dbMigrator;
-
-    public DatabaseMigrationHostedService(
-        GlobalSettings globalSettings,
-        ILogger<DatabaseMigrationHostedService> logger,
-        ILogger<DbMigrator> migratorLogger,
-        ILogger<JobListener> listenerLogger)
+    public class DatabaseMigrationHostedService : IHostedService, IDisposable
     {
-        _globalSettings = globalSettings;
-        _logger = logger;
-        _dbMigrator = new DbMigrator(globalSettings.SqlServer.ConnectionString, migratorLogger);
-    }
+        private readonly GlobalSettings _globalSettings;
+        private readonly ILogger<DatabaseMigrationHostedService> _logger;
+        private readonly DbMigrator _dbMigrator;
 
-    public virtual async Task StartAsync(CancellationToken cancellationToken)
-    {
-        // Wait 20 seconds to allow database to come online
-        await Task.Delay(20000);
-
-        var maxMigrationAttempts = 10;
-        for (var i = 1; i <= maxMigrationAttempts; i++)
+        public DatabaseMigrationHostedService(
+            GlobalSettings globalSettings,
+            ILogger<DatabaseMigrationHostedService> logger,
+            ILogger<DbMigrator> migratorLogger,
+            ILogger<JobListener> listenerLogger)
         {
-            try
+            _globalSettings = globalSettings;
+            _logger = logger;
+            _dbMigrator = new DbMigrator(globalSettings.SqlServer.ConnectionString, migratorLogger);
+        }
+
+        public virtual async Task StartAsync(CancellationToken cancellationToken)
+        {
+            // Wait 20 seconds to allow database to come online
+            await Task.Delay(20000);
+
+            var maxMigrationAttempts = 10;
+            for (var i = 1; i <= maxMigrationAttempts; i++)
             {
-                _dbMigrator.MigrateMsSqlDatabase(true, cancellationToken);
-                // TODO: Maybe flip a flag somewhere to indicate migration is complete??
-                break;
-            }
-            catch (SqlException e)
-            {
-                if (i >= maxMigrationAttempts)
+                try
                 {
-                    _logger.LogError(e, "Database failed to migrate.");
-                    throw;
+                    _dbMigrator.MigrateMsSqlDatabase(true, cancellationToken);
+                    // TODO: Maybe flip a flag somewhere to indicate migration is complete??
+                    break;
                 }
-                else
+                catch (SqlException e)
                 {
-                    _logger.LogError(e,
-                        "Database unavailable for migration. Trying again (attempt #{0})...", i + 1);
-                    await Task.Delay(20000);
+                    if (i >= maxMigrationAttempts)
+                    {
+                        _logger.LogError(e, "Database failed to migrate.");
+                        throw;
+                    }
+                    else
+                    {
+                        _logger.LogError(e,
+                            "Database unavailable for migration. Trying again (attempt #{0})...", i + 1);
+                        await Task.Delay(20000);
+                    }
                 }
             }
         }
-    }
 
-    public virtual Task StopAsync(CancellationToken cancellationToken)
-    {
-        return Task.FromResult(0);
-    }
+        public virtual Task StopAsync(CancellationToken cancellationToken)
+        {
+            return Task.FromResult(0);
+        }
 
-    public virtual void Dispose()
-    { }
+        public virtual void Dispose()
+        { }
+    }
 }