Use IKeychain for credentials.

Previously credentials were read by 4 separate interfaces/classes:

- `IKeychain`/`WindowsKeychain`
- `ILoginCache`/`LoginCache`
- `SimpleCredentialStore`
- `CredentialCache`

Make everything go via `IKeychain`.

Author: grokys

src/GitHub.Api/GitHub.Api.csproj

@@ -50,17 +50,17 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="ApiClientConfiguration.cs"/>
+    <Compile Include="ApiClientConfiguration.cs" />
     <Compile Include="..\..\script\src\ApiClientConfiguration_User.cs" Condition="$(Buildtype) == 'Internal'">
       <Link>ApiClientConfiguration_User.cs</Link>
     </Compile>
-    <Compile Include="ApiClientConfiguration_User.cs" Condition="$(Buildtype) != 'Internal'"/>
-    <Compile Include="ILoginCache.cs" />
+    <Compile Include="ApiClientConfiguration_User.cs" Condition="$(Buildtype) != 'Internal'" />
+    <Compile Include="IKeychain.cs" />
     <Compile Include="ILoginManager.cs" />
     <Compile Include="ITwoFactorChallengeHandler.cs" />
     <Compile Include="LoginManager.cs" />
-    <Compile Include="SimpleCredentialStore.cs" />
-    <Compile Include="WindowsLoginCache.cs" />
+    <Compile Include="KeychainCredentialStore.cs" />
+    <Compile Include="WindowsKeychain.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="..\common\SolutionInfo.cs">
       <Link>Properties\SolutionInfo.cs</Link>

src/GitHub.Api/IKeychain.cs

@@ -12,26 +12,27 @@ public interface IKeychain
         /// <summary>
         /// Loads the credentials for the specified host address.
         /// </summary>
-        /// <param name="hostAddress">The host address.</param>
+        /// <param name="address">The host address.</param>
         /// <returns>
-        /// A task returning a tuple consisting of the retrieved username and password.
+        /// A task returning a tuple consisting of the retrieved username and password or null
+        /// if the credentials were not found.
         /// </returns>
-        Task<Tuple<string, string>> Load(HostAddress hostAddress);
+        Task<Tuple<string, string>> Load(HostAddress address);
 
         /// <summary>
         /// Saves the credentials for the specified host address.
         /// </summary>
         /// <param name="userName">The username.</param>
         /// <param name="password">The password.</param>
-        /// <param name="hostAddress">The host address.</param>
+        /// <param name="address">The host address.</param>
         /// <returns>A task tracking the operation.</returns>
-        Task Save(string userName, string password, HostAddress hostAddress);
+        Task Save(string userName, string password, HostAddress address);
 
         /// <summary>
         /// Deletes the login details for the specified host address.
         /// </summary>
-        /// <param name="hostAddress"></param>
+        /// <param name="address"></param>
         /// <returns>A task tracking the operation.</returns>
-        Task Delete(HostAddress hostAddress);
+        Task Delete(HostAddress address);
     }
 }

src/GitHub.Api/KeychainCredentialStore.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Threading.Tasks;
+using GitHub.Extensions;
+using GitHub.Primitives;
+using Octokit;
+
+namespace GitHub.Api
+{
+    /// <summary>
+    /// An Octokit credential store that reads from an <see cref="IKeychain"/>.
+    /// </summary>
+    public class KeychainCredentialStore : ICredentialStore
+    {
+        readonly IKeychain keychain;
+        readonly HostAddress address;
+
+        public KeychainCredentialStore(IKeychain keychain, HostAddress address)
+        {
+            Guard.ArgumentNotNull(keychain, nameof(keychain));
+            Guard.ArgumentNotNull(address, nameof(keychain));
+
+            this.keychain = keychain;
+            this.address = address;
+        }
+
+        public async Task<Credentials> GetCredentials()
+        {
+            var userPass = await keychain.Load(address).ConfigureAwait(false);
+            return userPass != null ? new Credentials(userPass.Item1, userPass.Item2) : Credentials.Anonymous;
+        }
+    }
+}

src/GitHub.Api/LoginManager.cs

@@ -13,7 +13,7 @@ namespace GitHub.Api
     public class LoginManager : ILoginManager
     {
         readonly string[] scopes = { "user", "repo", "gist", "write:public_key" };
-        readonly IKeychain loginCache;
+        readonly IKeychain keychain;
         readonly ITwoFactorChallengeHandler twoFactorChallengeHandler;
         readonly string clientId;
         readonly string clientSecret;
@@ -42,7 +42,7 @@ public LoginManager(
             Guard.ArgumentNotEmptyString(clientId, nameof(clientId));
             Guard.ArgumentNotEmptyString(clientSecret, nameof(clientSecret));
 
-            this.loginCache = loginCache;
+            this.keychain = loginCache;
             this.twoFactorChallengeHandler = twoFactorChallengeHandler;
             this.clientId = clientId;
             this.clientSecret = clientSecret;
@@ -64,7 +64,7 @@ public async Task<User> Login(
 
             // Start by saving the username and password, these will be used by the `IGitHubClient`
             // until an authorization token has been created and acquired:
-            await loginCache.Save(userName, password, hostAddress).ConfigureAwait(false);
+            await keychain.Save(userName, password, hostAddress).ConfigureAwait(false);
 
             var newAuth = new NewAuthorization
             {
@@ -99,13 +99,13 @@ public async Task<User> Login(
                     }
                     else
                     {
-                        await loginCache.Delete(hostAddress).ConfigureAwait(false);
+                        await keychain.Delete(hostAddress).ConfigureAwait(false);
                         throw;
                     }
                 }
             } while (auth == null);
 
-            await loginCache.Save(userName, auth.Token, hostAddress).ConfigureAwait(false);
+            await keychain.Save(userName, auth.Token, hostAddress).ConfigureAwait(false);
 
             var retry = 0;
 
@@ -141,7 +141,7 @@ public async Task Logout(HostAddress hostAddress, IGitHubClient client)
             Guard.ArgumentNotNull(hostAddress, nameof(hostAddress));
             Guard.ArgumentNotNull(client, nameof(client));
 
-            await loginCache.Delete(hostAddress);
+            await keychain.Delete(hostAddress);
         }
 
         async Task<ApplicationAuthorization> CreateAndDeleteExistingApplicationAuthorization(
@@ -219,7 +219,7 @@ async Task<ApplicationAuthorization> HandleTwoFactorAuthorization(
                     catch (Exception e)
                     {
                         await twoFactorChallengeHandler.ChallengeFailed(e);
-                        await loginCache.Delete(hostAddress).ConfigureAwait(false);
+                        await keychain.Delete(hostAddress).ConfigureAwait(false);
                         throw;
                     }
                 }

src/GitHub.Api/SimpleApiClientFactory.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.ComponentModel.Composition;
 using GitHub.Models;
 using GitHub.Primitives;
@@ -14,15 +13,21 @@ namespace GitHub.Api
     [PartCreationPolicy(CreationPolicy.Shared)]
     public class SimpleApiClientFactory : ISimpleApiClientFactory
     {
+        readonly IKeychain keychain;
         readonly ProductHeaderValue productHeader;
         readonly Lazy<IEnterpriseProbeTask> lazyEnterpriseProbe;
         readonly Lazy<IWikiProbe> lazyWikiProbe;
 
         static readonly ConcurrentDictionary<UriString, ISimpleApiClient> cache = new ConcurrentDictionary<UriString, ISimpleApiClient>();
 
         [ImportingConstructor]
-        public SimpleApiClientFactory(IProgram program, Lazy<IEnterpriseProbeTask> enterpriseProbe, Lazy<IWikiProbe> wikiProbe)
+        public SimpleApiClientFactory(
+            IProgram program,
+            IKeychain keychain,
+            Lazy<IEnterpriseProbeTask> enterpriseProbe,
+            Lazy<IWikiProbe> wikiProbe)
         {
+            this.keychain = keychain;
             productHeader = program.ProductHeader;
             lazyEnterpriseProbe = enterpriseProbe;
             lazyWikiProbe = wikiProbe;
@@ -31,8 +36,9 @@ public SimpleApiClientFactory(IProgram program, Lazy<IEnterpriseProbeTask> enter
         public Task<ISimpleApiClient> Create(UriString repositoryUrl)
         {
             var hostAddress = HostAddress.Create(repositoryUrl);
+            var credentialStore = new KeychainCredentialStore(keychain, hostAddress);
             var result = cache.GetOrAdd(repositoryUrl, new SimpleApiClient(repositoryUrl,
-                new GitHubClient(productHeader, new SimpleCredentialStore(hostAddress), hostAddress.ApiUri),
+                new GitHubClient(productHeader, credentialStore, hostAddress.ApiUri),
                 lazyEnterpriseProbe, lazyWikiProbe));
             return Task.FromResult(result);
         }

src/GitHub.Api/SimpleCredentialStore.cs

@@ -29,7 +29,7 @@ public Task<Tuple<string, string>> Load(HostAddress hostAddress)
                     return Task.FromResult(Tuple.Create(credential.Username, credential.Password));
             }
 
-            return Task.FromResult(Tuple.Create<string, string>(null, null));
+            return Task.FromResult<Tuple<string, string>>(null);
         }
 
         /// <inheritdoc/>