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/Core/HostedServices/ApplicationCacheHostedService.cs

@@ -8,99 +8,100 @@ using Microsoft.Azure.ServiceBus.Management;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 
-namespace Bit.Core.HostedServices;
-
-public class ApplicationCacheHostedService : IHostedService, IDisposable
+namespace Bit.Core.HostedServices
 {
-    private readonly InMemoryServiceBusApplicationCacheService _applicationCacheService;
-    private readonly IOrganizationRepository _organizationRepository;
-    protected readonly ILogger<ApplicationCacheHostedService> _logger;
-    private readonly SubscriptionClient _subscriptionClient;
-    private readonly ManagementClient _managementClient;
-    private readonly string _subName;
-    private readonly string _topicName;
-
-    public ApplicationCacheHostedService(
-        IApplicationCacheService applicationCacheService,
-        IOrganizationRepository organizationRepository,
-        ILogger<ApplicationCacheHostedService> logger,
-        GlobalSettings globalSettings)
+    public class ApplicationCacheHostedService : IHostedService, IDisposable
     {
-        _topicName = globalSettings.ServiceBus.ApplicationCacheTopicName;
-        _subName = CoreHelpers.GetApplicationCacheServiceBusSubcriptionName(globalSettings);
-        _applicationCacheService = applicationCacheService as InMemoryServiceBusApplicationCacheService;
-        _organizationRepository = organizationRepository;
-        _logger = logger;
-        _managementClient = new ManagementClient(globalSettings.ServiceBus.ConnectionString);
-        _subscriptionClient = new SubscriptionClient(globalSettings.ServiceBus.ConnectionString,
-            _topicName, _subName);
-    }
+        private readonly InMemoryServiceBusApplicationCacheService _applicationCacheService;
+        private readonly IOrganizationRepository _organizationRepository;
+        protected readonly ILogger<ApplicationCacheHostedService> _logger;
+        private readonly SubscriptionClient _subscriptionClient;
+        private readonly ManagementClient _managementClient;
+        private readonly string _subName;
+        private readonly string _topicName;
 
-    public virtual async Task StartAsync(CancellationToken cancellationToken)
-    {
-        try
+        public ApplicationCacheHostedService(
+            IApplicationCacheService applicationCacheService,
+            IOrganizationRepository organizationRepository,
+            ILogger<ApplicationCacheHostedService> logger,
+            GlobalSettings globalSettings)
         {
-            await _managementClient.CreateSubscriptionAsync(new SubscriptionDescription(_topicName, _subName)
-            {
-                DefaultMessageTimeToLive = TimeSpan.FromDays(14),
-                LockDuration = TimeSpan.FromSeconds(30),
-                EnableDeadLetteringOnFilterEvaluationExceptions = true,
-                EnableDeadLetteringOnMessageExpiration = true,
-            }, new RuleDescription("default", new SqlFilter($"sys.Label != '{_subName}'")));
+            _topicName = globalSettings.ServiceBus.ApplicationCacheTopicName;
+            _subName = CoreHelpers.GetApplicationCacheServiceBusSubcriptionName(globalSettings);
+            _applicationCacheService = applicationCacheService as InMemoryServiceBusApplicationCacheService;
+            _organizationRepository = organizationRepository;
+            _logger = logger;
+            _managementClient = new ManagementClient(globalSettings.ServiceBus.ConnectionString);
+            _subscriptionClient = new SubscriptionClient(globalSettings.ServiceBus.ConnectionString,
+                _topicName, _subName);
         }
-        catch (MessagingEntityAlreadyExistsException) { }
-        _subscriptionClient.RegisterMessageHandler(ProcessMessageAsync,
-            new MessageHandlerOptions(ExceptionReceivedHandlerAsync)
-            {
-                MaxConcurrentCalls = 2,
-                AutoComplete = false,
-            });
-    }
 
-    public virtual async Task StopAsync(CancellationToken cancellationToken)
-    {
-        await _subscriptionClient.CloseAsync();
-        try
+        public virtual async Task StartAsync(CancellationToken cancellationToken)
         {
-            await _managementClient.DeleteSubscriptionAsync(_topicName, _subName, cancellationToken);
+            try
+            {
+                await _managementClient.CreateSubscriptionAsync(new SubscriptionDescription(_topicName, _subName)
+                {
+                    DefaultMessageTimeToLive = TimeSpan.FromDays(14),
+                    LockDuration = TimeSpan.FromSeconds(30),
+                    EnableDeadLetteringOnFilterEvaluationExceptions = true,
+                    EnableDeadLetteringOnMessageExpiration = true,
+                }, new RuleDescription("default", new SqlFilter($"sys.Label != '{_subName}'")));
+            }
+            catch (MessagingEntityAlreadyExistsException) { }
+            _subscriptionClient.RegisterMessageHandler(ProcessMessageAsync,
+                new MessageHandlerOptions(ExceptionReceivedHandlerAsync)
+                {
+                    MaxConcurrentCalls = 2,
+                    AutoComplete = false,
+                });
         }
-        catch { }
-    }
 
-    public virtual void Dispose()
-    { }
-
-    private async Task ProcessMessageAsync(Message message, CancellationToken cancellationToken)
-    {
-        if (message.Label != _subName && _applicationCacheService != null)
+        public virtual async Task StopAsync(CancellationToken cancellationToken)
         {
-            switch ((ApplicationCacheMessageType)message.UserProperties["type"])
+            await _subscriptionClient.CloseAsync();
+            try
             {
-                case ApplicationCacheMessageType.UpsertOrganizationAbility:
-                    var upsertedOrgId = (Guid)message.UserProperties["id"];
-                    var upsertedOrg = await _organizationRepository.GetByIdAsync(upsertedOrgId);
-                    if (upsertedOrg != null)
-                    {
-                        await _applicationCacheService.BaseUpsertOrganizationAbilityAsync(upsertedOrg);
-                    }
-                    break;
-                case ApplicationCacheMessageType.DeleteOrganizationAbility:
-                    await _applicationCacheService.BaseDeleteOrganizationAbilityAsync(
-                        (Guid)message.UserProperties["id"]);
-                    break;
-                default:
-                    break;
+                await _managementClient.DeleteSubscriptionAsync(_topicName, _subName, cancellationToken);
+            }
+            catch { }
+        }
+
+        public virtual void Dispose()
+        { }
+
+        private async Task ProcessMessageAsync(Message message, CancellationToken cancellationToken)
+        {
+            if (message.Label != _subName && _applicationCacheService != null)
+            {
+                switch ((ApplicationCacheMessageType)message.UserProperties["type"])
+                {
+                    case ApplicationCacheMessageType.UpsertOrganizationAbility:
+                        var upsertedOrgId = (Guid)message.UserProperties["id"];
+                        var upsertedOrg = await _organizationRepository.GetByIdAsync(upsertedOrgId);
+                        if (upsertedOrg != null)
+                        {
+                            await _applicationCacheService.BaseUpsertOrganizationAbilityAsync(upsertedOrg);
+                        }
+                        break;
+                    case ApplicationCacheMessageType.DeleteOrganizationAbility:
+                        await _applicationCacheService.BaseDeleteOrganizationAbilityAsync(
+                            (Guid)message.UserProperties["id"]);
+                        break;
+                    default:
+                        break;
+                }
+            }
+            if (!cancellationToken.IsCancellationRequested)
+            {
+                await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
             }
         }
-        if (!cancellationToken.IsCancellationRequested)
+
+        private Task ExceptionReceivedHandlerAsync(ExceptionReceivedEventArgs args)
         {
-            await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
+            _logger.LogError(args.Exception, "Message handler encountered an exception.");
+            return Task.FromResult(0);
         }
     }
-
-    private Task ExceptionReceivedHandlerAsync(ExceptionReceivedEventArgs args)
-    {
-        _logger.LogError(args.Exception, "Message handler encountered an exception.");
-        return Task.FromResult(0);
-    }
 }

src/Core/HostedServices/IpRateLimitSeedStartupService.cs

@@ -1,40 +1,41 @@
 using AspNetCoreRateLimit;
 using Microsoft.Extensions.Hosting;
 
-namespace Bit.Core.HostedServices;
-
-/// <summary>
-/// A startup service that will seed the IP rate limiting stores with any values in the
-/// GlobalSettings configuration.
-/// </summary>
-/// <remarks>
-/// <para>Using an <see cref="IHostedService"/> here because it runs before the request processing pipeline
-/// is configured, so that any rate limiting configuration is seeded/applied before any requests come in.
-/// </para>
-/// <para>
-/// This is a cleaner alternative to modifying Program.cs in every project that requires rate limiting as
-/// described/suggested here:
-/// https://github.com/stefanprodan/AspNetCoreRateLimit/wiki/Version-3.0.0-Breaking-Changes
-/// </para>
-/// </remarks>
-public class IpRateLimitSeedStartupService : IHostedService
+namespace Bit.Core.HostedServices
 {
-    private readonly IIpPolicyStore _ipPolicyStore;
-    private readonly IClientPolicyStore _clientPolicyStore;
-
-    public IpRateLimitSeedStartupService(IIpPolicyStore ipPolicyStore, IClientPolicyStore clientPolicyStore)
+    /// <summary>
+    /// A startup service that will seed the IP rate limiting stores with any values in the
+    /// GlobalSettings configuration.
+    /// </summary>
+    /// <remarks>
+    /// <para>Using an <see cref="IHostedService"/> here because it runs before the request processing pipeline
+    /// is configured, so that any rate limiting configuration is seeded/applied before any requests come in.
+    /// </para>
+    /// <para>
+    /// This is a cleaner alternative to modifying Program.cs in every project that requires rate limiting as
+    /// described/suggested here:
+    /// https://github.com/stefanprodan/AspNetCoreRateLimit/wiki/Version-3.0.0-Breaking-Changes
+    /// </para>
+    /// </remarks>
+    public class IpRateLimitSeedStartupService : IHostedService
     {
-        _ipPolicyStore = ipPolicyStore;
-        _clientPolicyStore = clientPolicyStore;
-    }
+        private readonly IIpPolicyStore _ipPolicyStore;
+        private readonly IClientPolicyStore _clientPolicyStore;
 
-    public async Task StartAsync(CancellationToken cancellationToken)
-    {
-        // Seed the policies from GlobalSettings
-        await _ipPolicyStore.SeedAsync();
-        await _clientPolicyStore.SeedAsync();
-    }
+        public IpRateLimitSeedStartupService(IIpPolicyStore ipPolicyStore, IClientPolicyStore clientPolicyStore)
+        {
+            _ipPolicyStore = ipPolicyStore;
+            _clientPolicyStore = clientPolicyStore;
+        }
 
-    // noop
-    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+        public async Task StartAsync(CancellationToken cancellationToken)
+        {
+            // Seed the policies from GlobalSettings
+            await _ipPolicyStore.SeedAsync();
+            await _clientPolicyStore.SeedAsync();
+        }
+
+        // noop
+        public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+    }
 }