Ensure all app resources are disposed on exit

Refactor the main `Application` class to be disposed on application exit.
All components that have `IDisposable` object references have now been
given a chance to dispose of them.

Author: mjcheetham

src/Microsoft.AzureRepos/AzureDevOpsRestApi.cs

@@ -12,7 +12,7 @@
 
 namespace Microsoft.AzureRepos
 {
-    public interface IAzureDevOpsRestApi
+    public interface IAzureDevOpsRestApi : IDisposable
     {
         Task<string> GetAuthorityAsync(Uri organizationUri);
         Task<string> CreatePersonalAccessTokenAsync(Uri organizationUri, string accessToken, IEnumerable<string> scopes);
@@ -289,7 +289,7 @@ private static HttpRequestMessage CreateRequestMessage(HttpMethod method, Uri ur
                 request.Content = content;
             }
 
-            if (!(bearerToken is null))
+            if (!string.IsNullOrWhiteSpace(bearerToken))
             {
                 request.Headers.Authorization = new AuthenticationHeaderValue(Constants.Http.WwwAuthenticateBearerScheme, bearerToken);
             }
@@ -298,5 +298,14 @@ private static HttpRequestMessage CreateRequestMessage(HttpMethod method, Uri ur
         }
 
         #endregion
+
+        #region IDisposable
+
+        public void Dispose()
+        {
+            _httpClient?.Dispose();
+        }
+
+        #endregion
     }
 }

src/Microsoft.AzureRepos/AzureReposHostProvider.cs

@@ -85,6 +85,16 @@ public override async Task<GitCredential> CreateCredentialAsync(InputArguments i
             return new GitCredential(Constants.PersonalAccessTokenUserName, pat);
         }
 
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                _azDevOps.Dispose();
+            }
+
+            base.Dispose(disposing);
+        }
+
         #endregion
     }
 }

src/Microsoft.Git.CredentialManager/Authentication/WindowsIntegratedAuthentication.cs

@@ -7,7 +7,7 @@
 
 namespace Microsoft.Git.CredentialManager.Authentication
 {
-    public interface IWindowsIntegratedAuthentication
+    public interface IWindowsIntegratedAuthentication : IDisposable
     {
         Task<bool> GetIsSupportedAsync(Uri uri);
     }
@@ -58,5 +58,14 @@ public async Task<bool> GetIsSupportedAsync(Uri uri)
 
         private HttpClient _httpClient;
         private HttpClient HttpClient => _httpClient ?? (_httpClient = _httpFactory.CreateClient());
+
+        #region IDisposable
+
+        public void Dispose()
+        {
+            _httpClient?.Dispose();
+        }
+
+        #endregion
     }
 }

src/Microsoft.Git.CredentialManager/GenericHostProvider.cs

@@ -71,6 +71,12 @@ public override async Task<GitCredential> CreateCredentialAsync(InputArguments i
             return _basicAuth.GetCredentials(uri.AbsoluteUri, uri.UserInfo);
         }
 
+        protected override void Dispose(bool disposing)
+        {
+            _winAuth.Dispose();
+            base.Dispose(disposing);
+        }
+
         #endregion
 
         #region Helpers

src/Microsoft.Git.CredentialManager/HostProvider.cs

@@ -1,13 +1,15 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license.
+
+using System;
 using System.Threading.Tasks;
 
 namespace Microsoft.Git.CredentialManager
 {
     /// <summary>
     /// Represents a particular Git hosting service and provides for the creation of credentials to access the remote.
     /// </summary>
-    public interface IHostProvider
+    public interface IHostProvider : IDisposable
     {
         /// <summary>
         /// Name of the hosting provider.
@@ -60,5 +62,22 @@ protected HostProvider(ICommandContext context)
         public abstract string GetCredentialKey(InputArguments input);
 
         public abstract Task<GitCredential> CreateCredentialAsync(InputArguments input);
+
+        /// <summary>
+        /// Called when the application is being terminated. Clean up and release any resources.
+        /// </summary>
+        /// <param name="disposing">True if the instance is being disposed, false if being finalized.</param>
+        protected virtual void Dispose(bool disposing) { }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        ~HostProvider()
+        {
+            Dispose(false);
+        }
     }
 }

src/Microsoft.Git.CredentialManager/HostProviderRegistry.cs

@@ -10,12 +10,16 @@ namespace Microsoft.Git.CredentialManager
     /// Represents a collection of <see cref="IHostProvider"/>s which are selected based on Git credential query
     /// <see cref="InputArguments"/>.
     /// </summary>
-    public interface IHostProviderRegistry
+    /// <remarks>
+    /// All registered <see cref="IHostProvider"/>s will be disposed when this <see cref="IHostProviderRegistry"/> is disposed.
+    /// </remarks>
+    public interface IHostProviderRegistry : IDisposable
     {
         /// <summary>
         /// Add the given <see cref="IHostProvider"/>(s) to this registry.
         /// </summary>
         /// <param name="hostProviders">A collection of providers to register.</param>
+        /// <remarks>Providers will be disposed of when this registry instance is disposed itself.</remarks>
         void Register(params IHostProvider[] hostProviders);
 
         /// <summary>
@@ -56,5 +60,14 @@ public IHostProvider GetProvider(InputArguments input)
 
             return provider;
         }
+
+        public void Dispose()
+        {
+            // Dispose of all registered providers to give them a chance to clean up and release any resources
+            foreach (IHostProvider provider in _hostProviders)
+            {
+                provider.Dispose();
+            }
+        }
     }
 }

src/git-credential-manager/Application.cs

@@ -12,105 +12,116 @@
 
 namespace Microsoft.Git.CredentialManager
 {
-    public static class Application
+    public class Application : IDisposable
     {
-        private static readonly IHostProviderRegistry HostProviderRegistry = new HostProviderRegistry();
+        private readonly ICommandContext _context;
+        private readonly IHostProviderRegistry _providerRegistry = new HostProviderRegistry();
 
-        private static readonly ICollection<CommandBase> Commands = new CommandBase[]
-        {
-            new EraseCommand(HostProviderRegistry),
-            new GetCommand(HostProviderRegistry),
-            new StoreCommand(HostProviderRegistry),
-            new VersionCommand(),
-            new HelpCommand(),
-        };
-
-        public static async Task<int> RunAsync(string[] args)
+        private TextWriter _traceFileWriter;
+
+        public Application(ICommandContext context)
         {
-            var context = new CommandContext();
+            EnsureArgument.NotNull(context, nameof(context));
+
+            _context = context;
+        }
 
+        public async Task<int> RunAsync(string[] args)
+        {
             // Launch debugger
-            if (context.IsEnvironmentVariableTruthy(Constants.EnvironmentVariables.GcmDebug, false))
+            if (_context.IsEnvironmentVariableTruthy(Constants.EnvironmentVariables.GcmDebug, false))
             {
-                context.StdError.WriteLine("Waiting for debugger to be attached...");
+                _context.StdError.WriteLine("Waiting for debugger to be attached...");
                 PlatformUtils.WaitForDebuggerAttached();
 
                 // Now the debugger is attached, break!
                 Debugger.Break();
             }
 
             // Enable tracing
-            if (context.TryGetEnvironmentVariable(Constants.EnvironmentVariables.GcmTrace, out string traceEnvar))
+            if (_context.TryGetEnvironmentVariable(Constants.EnvironmentVariables.GcmTrace, out string traceEnvar))
             {
                 if (traceEnvar.IsTruthy()) // Trace to stderr
                 {
-                    context.Trace.AddListener(context.StdError);
+                    _context.Trace.AddListener(_context.StdError);
                 }
                 else if (Path.IsPathRooted(traceEnvar) && // Trace to a file
-                         TryCreateTextWriter(context, traceEnvar, out var fileWriter))
+                         TryCreateTextWriter(_context, traceEnvar, out var fileWriter))
                 {
-                    context.Trace.AddListener(fileWriter);
+                    _traceFileWriter = fileWriter;
+                    _context.Trace.AddListener(fileWriter);
                 }
                 else
                 {
-                    context.StdError.WriteLine($"warning: cannot write trace output to {traceEnvar}");
+                    _context.StdError.WriteLine($"warning: cannot write trace output to {traceEnvar}");
                 }
             }
 
             // Enable sensitive tracing and show warning
-            if (context.IsEnvironmentVariableTruthy(Constants.EnvironmentVariables.GcmTraceSecrets, false))
+            if (_context.IsEnvironmentVariableTruthy(Constants.EnvironmentVariables.GcmTraceSecrets, false))
             {
-                context.Trace.EnableSecretTracing = true;
-                context.StdError.WriteLine(
-                    "warning: Secret tracing is enabled. Trace output may contain sensitive information.");
+                _context.Trace.EnableSecretTracing = true;
+                _context.StdError.WriteLine("Secret tracing is enabled. Trace output may contain sensitive information.");
             }
 
             // Register all supported host providers
-            HostProviderRegistry.Register(
-                new AzureReposHostProvider(context),
-                new GenericHostProvider(context)
+            _providerRegistry.Register(
+                new AzureReposHostProvider(_context),
+                new GenericHostProvider(_context)
             );
 
+            // Construct all supported commands
+            var commands = new CommandBase[]
+            {
+                new EraseCommand(_providerRegistry),
+                new GetCommand(_providerRegistry),
+                new StoreCommand(_providerRegistry),
+                new VersionCommand(),
+                new HelpCommand(),
+            };
+
             // Trace the current version and program arguments
-            context.Trace.WriteLine($"{Constants.GetProgramHeader()} '{string.Join(" ", args)}'");
+            _context.Trace.WriteLine($"{Constants.GetProgramHeader()} '{string.Join(" ", args)}'");
 
             if (args.Length == 0)
             {
-                context.StdError.WriteLine("Missing command.");
-                HelpCommand.PrintUsage(context.StdError);
+                _context.StdError.WriteLine("Missing command.");
+                HelpCommand.PrintUsage(_context.StdError);
                 return -1;
             }
 
-            foreach (var cmd in Commands)
+            foreach (var cmd in commands)
             {
                 if (cmd.CanExecute(args))
                 {
                     try
                     {
-                        await cmd.ExecuteAsync(context, args);
+                        await cmd.ExecuteAsync(_context, args);
                         return 0;
                     }
                     catch (Exception e)
                     {
                         if (e is AggregateException ae)
                         {
-                            ae.Handle(x => WriteException(context, x));
+                            ae.Handle(x => WriteException(_context, x));
                         }
                         else
                         {
-                            WriteException(context, e);
+                            WriteException(_context, e);
                         }
 
                         return -1;
                     }
                 }
             }
 
-            context.StdError.WriteLine("Unrecognized command '{0}'.", args[0]);
-            HelpCommand.PrintUsage(context.StdError);
+            _context.StdError.WriteLine("Unrecognized command '{0}'.", args[0]);
+            HelpCommand.PrintUsage(_context.StdError);
             return -1;
         }
 
+        #region Helpers
+
         private static bool WriteException(ICommandContext context, Exception e)
         {
             context.StdError.WriteLine("fatal: {0}", e.Message);
@@ -140,5 +151,17 @@ private static bool TryCreateTextWriter(ICommandContext context, string path, ou
 
             return writer != null;
         }
+
+        #endregion
+
+        #region IDisposable
+
+        public void Dispose()
+        {
+            _providerRegistry.Dispose();
+            _traceFileWriter?.Dispose();
+        }
+
+        #endregion
     }
 }

src/git-credential-manager/Program.cs

@@ -8,8 +8,11 @@ public static class Program
     {
         public static void Main(string[] args)
         {
-            int exitCode = Application.RunAsync(args).ConfigureAwait(false).GetAwaiter().GetResult();
-            Environment.Exit(exitCode);
+            using (var app = new Application(new CommandContext()))
+            {
+                int exitCode = app.RunAsync(args).ConfigureAwait(false).GetAwaiter().GetResult();
+               Environment.Exit(exitCode);
+            }
         }
     }
 }

tests/Microsoft.Git.CredentialManager.Tests/Objects/TestHostProvider.cs

@@ -25,5 +25,11 @@ public class TestHostProvider : IHostProvider
         Task<GitCredential> IHostProvider.CreateCredentialAsync(InputArguments input) => Task.FromResult(Credential);
 
         #endregion
+
+        #region IDisposable
+
+        public void Dispose() { }
+
+        #endregion
     }
 }

tests/Microsoft.Git.CredentialManager.Tests/Objects/TestHostProviderRegistry.cs

@@ -18,5 +18,10 @@ IHostProvider IHostProviderRegistry.GetProvider(InputArguments input)
         }
 
         #endregion
+
+        public void Dispose()
+        {
+            Provider?.Dispose();
+        }
     }
 }