Get tenant & client IDs from configuration

calebkiage · calebkiage · commit f5b658c664ac · 2021-12-20T16:15:36.000+03:00
diff --git a/.github/workflows/build-cli.yml b/.github/workflows/build-cli.yml
@@ -13,8 +13,6 @@ jobs:
         with:
           dotnet-version: 6.x
       - name: Add NuGet kiota source
-        # TODO: Add NUGET_USER and NUGET_PASSWORD secrets
-        # TODO: Add NUGET_URL to env
         # NOTE: Password encryption is not supported for the linux platform (Encryption is only supported on Windows platforms.)
         run: |
           dotnet nuget add source ${{env.NUGET_URL}} -n github -u ${{secrets.NUGET_USER}} -p ${{secrets.NUGET_PASSWORD}} --store-password-in-clear-text
diff --git a/.github/workflows/release-cli.yml b/.github/workflows/release-cli.yml
@@ -0,0 +1,55 @@
+name: "Release CLI"
+on: workflow_dispatch  # Run manually. Incomplete workflow
+jobs:
+  build-windows:
+    runs-on: ubuntu-latest
+    env:
+      NUGET_URL: https://nuget.pkg.github.com/microsoft/index.json
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Setup .NET Core SDK 6
+        uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: 6.x
+      - name: Add NuGet kiota source
+        # NOTE: Password encryption is not supported for the linux platform (Encryption is only supported on Windows platforms.)
+        run: |
+          dotnet nuget add source ${{env.NUGET_URL}} -n github -u ${{secrets.NUGET_USER}} -p ${{secrets.NUGET_PASSWORD}} --store-password-in-clear-text
+      - uses: actions/cache@v2
+        with:
+          path: ~/.nuget/packages
+          # Look to see if there is a cache hit for the corresponding requirements file
+          key: ${{ runner.os }}-nuget-${{ hashFiles('**/packages.lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-nuget
+      - name: Install dependencies
+        run: dotnet restore
+      - name: Build
+        run: dotnet publish --runtime win-x64 --self-contained true --configuration Release --no-restore
+  build-mac:
+    runs-on: ubuntu-latest
+    env:
+      NUGET_URL: https://nuget.pkg.github.com/microsoft/index.json
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Setup .NET Core SDK 6
+        uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: 6.x
+      - name: Add NuGet kiota source
+        # NOTE: Password encryption is not supported for the linux platform (Encryption is only supported on Windows platforms.)
+        run: |
+          dotnet nuget add source ${{env.NUGET_URL}} -n github -u ${{secrets.NUGET_USER}} -p ${{secrets.NUGET_PASSWORD}} --store-password-in-clear-text
+      - uses: actions/cache@v2
+        with:
+          path: ~/.nuget/packages
+          # Look to see if there is a cache hit for the corresponding requirements file
+          key: ${{ runner.os }}-nuget-${{ hashFiles('**/packages.lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-nuget
+      - name: Install dependencies
+        run: dotnet restore
+      - name: Build
+        run: dotnet publish --runtime osx-x64 --self-contained true --configuration Release --no-restore
diff --git a/.gitignore b/.gitignore
@@ -571,3 +571,6 @@ FodyWeavers.xsd
 # Additional files built by Visual Studio
 
 # End of https://www.toptal.com/developers/gitignore/api/visualstudiocode,visualstudio,intellij+all,dotnetcore,windows,macos,linux
+
+app-settings.*.json
+!app-settings.sample.json
diff --git a/.vscode/launch.json b/.vscode/launch.json
@@ -11,7 +11,8 @@
             "preLaunchTask": "build",
             "program": "${workspaceFolder}/src/bin/Debug/net6.0/mgc.dll",
             "args": ["-h"],
-            "cwd": "${workspaceFolder}",
+            "cwd": "${workspaceFolder}/src",
+            "envFile": "${workspaceFolder}/src/.env",
             "console": "internalConsole",
             "stopAtEntry": false
         },
@@ -22,7 +23,8 @@
             "preLaunchTask": "build",
             "program": "${workspaceFolder}/src/bin/Debug/net6.0/mgc.dll",
             "args": ["login", "--scopes", "User.ReadWrite Mail.ReadWrite"],
-            "cwd": "${workspaceFolder}",
+            "cwd": "${workspaceFolder}/src",
+            "envFile": "${workspaceFolder}/src/.env",
             "console": "internalConsole",
             "stopAtEntry": false
         },
@@ -33,7 +35,8 @@
             "preLaunchTask": "build",
             "program": "${workspaceFolder}/src/bin/Debug/net6.0/mgc.dll",
             "args": ["me", "get"],
-            "cwd": "${workspaceFolder}",
+            "cwd": "${workspaceFolder}/src",
+            "envFile": "${workspaceFolder}/src/.env",
             "console": "internalConsole",
             "stopAtEntry": false
         },
diff --git a/src/.env b/src/.env
@@ -0,0 +1 @@
+DOTNET_ENVIRONMENT=Development
diff --git a/src/Authentication/AuthenticationServiceFactory.cs b/src/Authentication/AuthenticationServiceFactory.cs
@@ -3,40 +3,43 @@
 using System.Threading.Tasks;
 using Azure.Core;
 using Azure.Identity;
+using Microsoft.Extensions.Options;
+using Microsoft.Graph.Cli.Configuration;
+using Microsoft.Graph.Cli.IO;
 using Microsoft.Graph.Cli.Utils;
 
 namespace Microsoft.Graph.Cli.Authentication;
 
 class AuthenticationServiceFactory {
-    public async Task<ILoginService> GetAuthenticationServiceAsync(AuthenticationStrategy strategy) {
+    public async Task<ILoginService> GetAuthenticationServiceAsync(AuthenticationStrategy strategy, string tenantId, string clientId) {
         switch (strategy) {
             case AuthenticationStrategy.DeviceCode:
-                return await GetDeviceCodeLoginServiceAsync();
+                return await GetDeviceCodeLoginServiceAsync(tenantId, clientId);
             default:
                 throw new InvalidOperationException($"The authentication strategy {strategy} is not supported");
         }
 
     }
 
-    public async Task<TokenCredential> GetTokenCredentialAsync(AuthenticationStrategy strategy) {
+    public async Task<TokenCredential> GetTokenCredentialAsync(AuthenticationStrategy strategy, string tenantId, string clientId) {
         switch (strategy) {
             case AuthenticationStrategy.DeviceCode:
-                return await GetDeviceCodeCredentialAsync();
+                return await GetDeviceCodeCredentialAsync(tenantId, clientId);
             default:
                 throw new InvalidOperationException($"The authentication strategy {strategy} is not supported");
         }
     }
 
-    private async Task<DeviceCodeLoginService> GetDeviceCodeLoginServiceAsync() {
-        var credential = await GetDeviceCodeCredentialAsync();
-        return new(credential);
+    private async Task<DeviceCodeLoginService> GetDeviceCodeLoginServiceAsync(string tenantId, string clientId) {
+        var credential = await GetDeviceCodeCredentialAsync(tenantId, clientId);
+        return new(credential, new PathUtility());
     }
 
-    private async Task<DeviceCodeCredential> GetDeviceCodeCredentialAsync() {
+    private async Task<DeviceCodeCredential> GetDeviceCodeCredentialAsync(string tenantId, string clientId) {
         DeviceCodeCredentialOptions credOptions = new()
         {
-            ClientId = Constants.ClientId,
-            TenantId = Constants.TenantId
+            ClientId = clientId,
+            TenantId = tenantId,
         };
 
         TokenCachePersistenceOptions tokenCacheOptions = new() { Name = Constants.TokenCacheName };
diff --git a/src/Authentication/DeviceCodeLoginService.cs b/src/Authentication/DeviceCodeLoginService.cs
@@ -1,5 +1,6 @@
 using Azure.Core;
 using Azure.Identity;
+using Microsoft.Graph.Cli.IO;
 using Microsoft.Graph.Cli.Utils;
 using System.IO;
 using System.Threading.Tasks;
@@ -9,7 +10,7 @@ namespace Microsoft.Graph.Cli.Authentication;
 class DeviceCodeLoginService : LoginServiceBase {
     private DeviceCodeCredential credential;
 
-    public DeviceCodeLoginService(DeviceCodeCredential credential) {
+    public DeviceCodeLoginService(DeviceCodeCredential credential, IPathUtility pathUtility) : base(pathUtility) {
         this.credential = credential;
     }
 
diff --git a/src/Authentication/LoginServiceBase.cs b/src/Authentication/LoginServiceBase.cs
@@ -2,11 +2,18 @@
 using System.IO;
 using System.Threading.Tasks;
 using Azure.Identity;
+using Microsoft.Graph.Cli.IO;
 using Microsoft.Graph.Cli.Utils;
 
 namespace Microsoft.Graph.Cli.Authentication;
 
 abstract class LoginServiceBase : ILoginService {
+    private readonly IPathUtility pathUtility;
+
+    protected LoginServiceBase(IPathUtility pathUtility) {
+        this.pathUtility = pathUtility;
+    }
+
     public async Task LoginAsync(string[] scopes) {
         var record = await this.DoLoginAsync(scopes);
         await this.SaveSessionAsync(record);
@@ -15,7 +22,7 @@ public async Task LoginAsync(string[] scopes) {
     protected abstract Task<AuthenticationRecord> DoLoginAsync(string[] scopes);
 
     public async Task SaveSessionAsync(AuthenticationRecord record) {
-        var homeDir = Environment.GetEnvironmentVariable("HOME") ?? Environment.ExpandEnvironmentVariables("%HOMEDRIVE%%HOMEPATH%");
+        var homeDir = pathUtility.GetUserHomeDirectory();
         var recordPath = Path.Combine(homeDir, Constants.ApplicationDataDirectory, Constants.AuthRecordPath);
         using var authRecordStream = new FileStream(recordPath, FileMode.OpenOrCreate, FileAccess.Write);
         await record.SerializeAsync(authRecordStream);
diff --git a/src/Commands/Authentication/LoginCommand.cs b/src/Commands/Authentication/LoginCommand.cs
@@ -1,4 +1,8 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Options;
 using Microsoft.Graph.Cli.Authentication;
+using Microsoft.Graph.Cli.Configuration;
 using Microsoft.Graph.Cli.Utils;
 using System.CommandLine;
 using System.CommandLine.Invocation;
@@ -23,9 +27,10 @@ public Command Build() {
         var strategy = new Option<AuthenticationStrategy>("--strategy", () => Constants.defaultAuthStrategy, "The authentication strategy to use.");
         loginCommand.AddOption(strategy);
 
-        loginCommand.Handler = CommandHandler.Create<string[], AuthenticationStrategy>(async (scopes, strategy) =>
+        loginCommand.Handler = CommandHandler.Create<string[], AuthenticationStrategy, IHost>(async (scopes, strategy, host) =>
         {
-            var authService = await this.authenticationServiceFactory.GetAuthenticationServiceAsync(strategy);
+            var options = host.Services.GetRequiredService<IOptionsMonitor<AuthenticationOptions>>().CurrentValue;
+            var authService = await this.authenticationServiceFactory.GetAuthenticationServiceAsync(strategy, options?.TenantId, options?.ClientId);
             await authService.LoginAsync(scopes);
         });
 
diff --git a/src/Configuration/AuthenticationOptions.cs b/src/Configuration/AuthenticationOptions.cs
@@ -0,0 +1,7 @@
+namespace Microsoft.Graph.Cli.Configuration;
+
+public class AuthenticationOptions {
+    public string TenantId { get; set; }
+
+    public string ClientId { get; set; }
+}
diff --git a/src/IO/IPathUtility.cs b/src/IO/IPathUtility.cs
@@ -0,0 +1,5 @@
+namespace Microsoft.Graph.Cli.IO;
+
+public interface IPathUtility {
+    string GetUserHomeDirectory();
+}
diff --git a/src/IO/PathUtility.cs b/src/IO/PathUtility.cs
@@ -0,0 +1,9 @@
+using System;
+
+namespace Microsoft.Graph.Cli.IO;
+
+public class PathUtility : IPathUtility {
+    public string GetUserHomeDirectory() {
+        return Environment.GetEnvironmentVariable("HOME") ?? Environment.ExpandEnvironmentVariables("%HOMEDRIVE%%HOMEPATH%");
+    }
+}
diff --git a/src/Program.cs b/src/Program.cs
@@ -1,25 +1,43 @@
 ﻿using ApiSdk;
 using Azure.Identity;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
 using Microsoft.Graph.Cli.Authentication;
 using Microsoft.Graph.Cli.Commands.Authentication;
+using Microsoft.Graph.Cli.Configuration;
+using Microsoft.Graph.Cli.IO;
 using Microsoft.Graph.Cli.Utils;
 using Microsoft.Kiota.Authentication.Azure;
 using Microsoft.Kiota.Http.HttpClientLibrary;
 using System.CommandLine;
+using System.CommandLine.Builder;
+using System.CommandLine.Hosting;
+using System.CommandLine.Parsing;
+using System.IO;
 using System.Net.Http;
 using System.Reflection;
 using System.Threading.Tasks;
 
 namespace Microsoft.Graph.Cli
 {
-    class Program {
+    class Program
+    {
         const string SdkVersionHeaderValueFormatString = "{0}-cli-{1}.{2}.{3}";
 
-        static async Task<int> Main(string[] args) {
+        static async Task<int> Main(string[] args)
+        {
+            // We don't have access to a built host yet. Get configuration settings using a configuration builder.
+            // Required to set initial token credentials.
+            var configBuilder = new ConfigurationBuilder();
+            ConfigureAppConfiguration(configBuilder);
+            var config = configBuilder.Build();
+
+            var authSettings = config.GetRequiredSection(Constants.AuthenticationSection).Get<AuthenticationOptions>();
             var authServiceFactory = new AuthenticationServiceFactory();
             var authStrategy = AuthenticationStrategy.DeviceCode;
 
-            var credential = await authServiceFactory.GetTokenCredentialAsync(authStrategy);
+            var credential = await authServiceFactory.GetTokenCredentialAsync(authStrategy, authSettings.TenantId, authSettings.ClientId);
             var authProvider = new AzureIdentityAuthenticationProvider(credential);
             var httpClient = new HttpClient();
             var assemblyVersion = Assembly.GetExecutingAssembly().GetName().Version;
@@ -32,16 +50,47 @@ static async Task<int> Main(string[] args) {
             httpClient.DefaultRequestHeaders.Add("SdkVersion", sdkVersionHeaderValue);
             var core = new HttpClientRequestAdapter(authProvider, null, null, httpClient);
             var client = new GraphClient(core);
+            var builder = BuildCommandLine(client);
+
+            var loginCommand = new LoginCommand(authServiceFactory);
+            builder.AddCommand(loginCommand.Build());
+
+            var logoutCommand = new LogoutCommand(new LogoutService());
+            builder.AddCommand(logoutCommand.Build());
+
+            var parser = builder.UseHost(CreateHostBuilder).UseDefaults().Build();
 
+            return await parser.InvokeAsync(args);
+        }
+
+        static CommandLineBuilder BuildCommandLine(GraphClient client)
+        {
             var rootCommand = client.BuildCommand();
             rootCommand.Description = "Microsoft Graph CLI";
 
-            var loginCommand = new LoginCommand(authServiceFactory);
-            rootCommand.AddCommand(loginCommand.Build());
+            return new CommandLineBuilder(rootCommand);
+        }
 
-            var logoutCommand = new LogoutCommand(new LogoutService());
-            rootCommand.AddCommand(logoutCommand.Build());
-            return await rootCommand.InvokeAsync(args);
+        static IHostBuilder CreateHostBuilder(string[] args) =>
+            Host.CreateDefaultBuilder().ConfigureHostConfiguration((configHost) => {
+                configHost.SetBasePath(Directory.GetCurrentDirectory());
+            }).ConfigureAppConfiguration((ctx, config) => {
+                var env = ctx.HostingEnvironment;
+                ConfigureAppConfiguration(config);
+                config.AddJsonFile($"app-settings.{env.EnvironmentName}.json", optional: true, true);
+            }).ConfigureServices((ctx, services) => {
+                var authSection = ctx.Configuration.GetSection(Constants.AuthenticationSection);
+                services.Configure<AuthenticationOptions>(authSection);
+                services.AddSingleton<IPathUtility, PathUtility>();
+            });
+        
+        static void ConfigureAppConfiguration(IConfigurationBuilder builder) {
+            builder.Sources.Clear();
+            builder.AddJsonFile("app-settings.json", optional: true);
+            var home = new PathUtility().GetUserHomeDirectory();
+            var userConfigPath = Path.Combine(home, Constants.ApplicationDataDirectory, "settings.json");
+            builder.AddJsonFile(userConfigPath);
+            builder.AddEnvironmentVariables(prefix: "MGC_");
         }
     }
 }
diff --git a/src/app-settings.json b/src/app-settings.json
@@ -0,0 +1,7 @@
+{
+    "Logging": {
+        "LogLevel": {
+            "Default": "Warning"
+        }
+    }
+}
diff --git a/src/app-settings.sample.json b/src/app-settings.sample.json
@@ -0,0 +1,6 @@
+{
+    "Authentication": {
+        "ClientId": "client id",
+        "TenantId": "tenant id"
+    }
+}
diff --git a/src/msgraph-cli.csproj b/src/msgraph-cli.csproj
@@ -13,13 +13,24 @@
     <Version>0.1.0-preview1</Version>
   </PropertyGroup>
 
+  <ItemGroup>
+    <Content Include="app-settings.json">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="Azure.Identity" Version="1.5.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="6.0.0" />
     <PackageReference Include="Microsoft.Kiota.Abstractions" Version="1.0.25" />
     <PackageReference Include="Microsoft.Kiota.Authentication.Azure" Version="1.0.6" />
     <PackageReference Include="Microsoft.Kiota.Http.HttpClientLibrary" Version="1.0.16" />
     <PackageReference Include="Microsoft.Kiota.Serialization.Json" Version="1.0.6" />
     <PackageReference Include="System.CommandLine" Version="2.0.0-beta1.21308.1" />
+    <PackageReference Include="System.CommandLine.Hosting" Version="0.3.0-alpha.21216.1" />
   </ItemGroup>
 
 </Project>
diff --git a/src/utils/Constants.cs b/src/utils/Constants.cs
