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);
-    }
 }