First checkin with GetAccessToken

Author: odaibert

src/GetAzureUserToken/GetAzureUserToken.csproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp2.2</TargetFramework>
+  </PropertyGroup>
+
+</Project>

src/GetAzureUserToken/Program.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Diagnostics;
+
+namespace GetAzureUserToken
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            Console.WriteLine("Hello World!");
+            var p = new Process();
+            p.StartInfo.FileName = "cmd.exe";
+            p.StartInfo.Arguments = @"/c az account get-access-token --query accessToken --output json ";
+            p.StartInfo.CreateNoWindow = true;
+            p.StartInfo.RedirectStandardError = true;
+            p.StartInfo.RedirectStandardOutput = true;
+            p.StartInfo.RedirectStandardInput = false;
+            p.OutputDataReceived += (a, b) => Console.WriteLine(b.Data);
+            p.ErrorDataReceived += (a, b) => Console.WriteLine(b.Data);
+            p.Start();
+            p.BeginErrorReadLine();
+            p.BeginOutputReadLine();
+            p.WaitForExit();
+            Console.ReadKey();
+        }
+    }
+}

src/apimtemplate/Commands/Extract.cs

@@ -1,7 +1,11 @@
 using System;
 using McMaster.Extensions.CommandLineUtils;
-using McMaster.Extensions.CommandLineUtils.HelpText;
 using Colors.Net;
+using System.Runtime.InteropServices;
+using System.Diagnostics;
+using System.Net.Http;
+using System.Net.Http.Headers;
+
 
 namespace Microsoft.Azure.Management.ApiManagement.ArmTemplates
 {
@@ -13,16 +17,45 @@ public ExtractCommand()
             this.Description = Constants.ExtractDescription;
 
             var apimname = this.Option("--name <apimname>", "API Management name", CommandOptionType.SingleValue).IsRequired();
+
+            var auth = new Authentication();
+
+            var aztoken = auth.GetAccessToken().Result;
+
             this.HelpOption();
 
-            this.OnExecute(() =>
+            this.OnExecute(async () =>
             {
                 if (apimname.HasValue())
+                {
                     Console.WriteLine($"Create command executed with name {apimname.Value()}");
+
+                    string requestUrl = string.Concat("https://management.azure.com/providers/Microsoft.ApiManagement/operations?api-version=2018-06-01-preview");//, "/groups", "?api-version=", "2018-06-01-preview");
+
+                    using (HttpClient httpClient = new HttpClient())
+                    {
+                        var request = new HttpRequestMessage(HttpMethod.Get, requestUrl);
+
+                        request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", aztoken);
+
+                        HttpResponseMessage response = await httpClient.SendAsync(request);
+
+                        response.EnsureSuccessStatusCode();
+
+                        string responseBody = await response.Content.ReadAsStringAsync();
+
+                        ColoredConsole.Write(responseBody.ToString());
+                        Console.ReadKey();
+                    }
+                }
                 else
+                {
                     ColoredConsole.Error.WriteLine("API Management name passed in");
+                }
                 return 0;
             });
+
         }
     }
-}
+}
+ 

src/apimtemplate/Common/Constants.cs

@@ -11,6 +11,7 @@ internal static class Constants
         public const string CreateDescription = "Create an API Management instance from files";
         public const string ExtractName = "extract";
         public const string ExtractDescription = "Extract an existing API Management instance";
-        
+
+        public const string azParameters = "account get-access-token --query \"accessToken\" --output json";
     }
 }

src/apimtemplate/Common/Executable.cs

@@ -0,0 +1,84 @@
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace Microsoft.Azure.Management.ApiManagement.ArmTemplates
+{
+    internal class Executable
+    {
+        private string _arguments;
+        private string _exeName;
+        private bool _shareConsole;
+        private bool _streamOutput;
+        private readonly bool _visibleProcess;
+        private readonly string _workingDirectory;
+
+        public Executable(string exeName, string arguments = null, bool streamOutput = true, bool shareConsole = false, bool visibleProcess = false, string workingDirectory = null)
+        {
+            _exeName = exeName;
+            _arguments = arguments;
+            _streamOutput = streamOutput;
+            _shareConsole = shareConsole;
+            _visibleProcess = visibleProcess;
+            _workingDirectory = workingDirectory;
+        }
+
+        public Process Process { get; private set; }
+
+        public async Task<int> RunAsync(Action<string> outputCallback = null, Action<string> errorCallback = null, TimeSpan? timeout = null)
+        {
+            var processInfo = new ProcessStartInfo
+            {
+                FileName = _exeName,
+                Arguments = _arguments,
+                CreateNoWindow = !_visibleProcess,
+                UseShellExecute = _shareConsole,
+                RedirectStandardError = _streamOutput,
+                RedirectStandardInput = _streamOutput,
+                RedirectStandardOutput = _streamOutput,
+                WorkingDirectory = _workingDirectory ?? Environment.CurrentDirectory
+            };
+
+            try
+            {
+                Process = Process.Start(processInfo);
+            }
+            catch (Win32Exception ex)
+            {
+                if (ex.Message == "The system cannot find the file specified")
+                {
+                    throw new FileNotFoundException(ex.Message, ex);
+                }
+                throw ex;
+            }
+
+            if (_streamOutput)
+            {
+                Process.OutputDataReceived += (s, e) => outputCallback?.Invoke(e.Data);
+                Process.BeginOutputReadLine();
+                Process.ErrorDataReceived += (s, e) => errorCallback?.Invoke(e.Data);
+                Process.BeginErrorReadLine();
+                Process.EnableRaisingEvents = true;
+            }
+
+            var exitCodeTask = Process.WaitForExitAsync();
+
+            if (timeout == null)
+                return await exitCodeTask;
+            else
+            {
+                await Task.WhenAny(exitCodeTask, Task.Delay(timeout.Value));
+
+                if (exitCodeTask.IsCompleted)
+                    return exitCodeTask.Result;
+                else
+                {
+                    Process.Kill();
+                    throw new Exception("Process didn't exit within specified timeout");
+                }
+            }
+        }
+    }
+}

src/apimtemplate/Common/ProcessExtensions.cs

@@ -0,0 +1,23 @@
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.Azure.Management.ApiManagement.ArmTemplates
+{
+    internal static class ProcessExtensions
+    {
+        // http://stackoverflow.com/a/19104345
+        public static Task<int> WaitForExitAsync(this Process process, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            var tcs = new TaskCompletionSource<int>();
+            process.EnableRaisingEvents = true;
+
+            process.Exited += (sender, args) => tcs.TrySetResult(process.ExitCode);
+
+            if (cancellationToken != default(CancellationToken))
+                cancellationToken.Register(tcs.SetCanceled);
+
+            return tcs.Task;
+        }
+    }
+}

src/apimtemplate/Common/SASAuthentication.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace Microsoft.Azure.Management.ApiManagement.ArmTemplates
+{
+    public class SASAuthentication
+    {
+        // api-version query parameter - https://aka.ms/smapi#VersionQueryParameter
+        static string apiVersion = "2014-02-14-preview";
+
+        static string serviceName = "contoso5";
+        static string baseUrl = string.Format("https://{0}.management.azure-api.net", serviceName);
+
+        #region [TBI] SAS from Portal 
+        // You can get an access token from the API Management portal or you can programmatically generate it. For
+        // more instructions on both approaches, see http://aka.ms/smapi#Authentication
+        // One common cause of 401 Unauthorized response codes is when the Expiry date of the token that was
+        // generated in the publisher portal has passed. If that happens, regenerate the token using the directions 
+        // in the link above. If you programmatically generate the token this typically does not happen.
+        // To use a token generated in the publisher portal, follow the "To manually create an access token" instructions
+        // at http://aka.ms/smapi#Authentication and paste in the token using the following format.
+        static string sharedAccessSignature = "uid=...&ex=...";
+
+        // To programmatically generate the token, call the CreateSharedAccessToken method below.
+        #endregion
+
+        public void GetSAStoken(string id, string key)
+        {
+            DateTime expiry = DateTime.UtcNow.AddDays(1);
+
+            sharedAccessSignature = CreateSharedAccessToken(id, key, expiry);
+
+        }
+        static private string CreateSharedAccessToken(string id, string key, DateTime expiry)
+        {
+            using (var encoder = new HMACSHA512(Encoding.UTF8.GetBytes(key)))
+            {
+                string dataToSign = id + "\n" + expiry.ToString("O", CultureInfo.InvariantCulture);
+                string x = string.Format("{0}\n{1}", id, expiry.ToString("O", CultureInfo.InvariantCulture));
+                var hash = encoder.ComputeHash(Encoding.UTF8.GetBytes(dataToSign));
+                var signature = Convert.ToBase64String(hash);
+                string encodedToken = string.Format("uid={0}&ex={1:o}&sn={2}", id, expiry, signature);
+                return encodedToken;
+            }
+        }
+    }
+}

src/apimtemplate/Common/Util.cs

@@ -0,0 +1,16 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Microsoft.Azure.Management.ApiManagement.ArmTemplates
+{
+    class Util
+    {
+        private static string FormatJSON(string json)
+        {
+            dynamic parsedJson = JsonConvert.DeserializeObject(json);
+            return JsonConvert.SerializeObject(parsedJson, Formatting.Indented);
+        }
+    }
+}

src/apimtemplate/Common/az-authentication.cs

@@ -0,0 +1,42 @@
+using Colors.Net;
+using Microsoft.Azure.Management.ApiManagement.ArmTemplates;
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Microsoft.Azure.Management.ApiManagement.ArmTemplates
+{
+    public class Authentication
+    {
+        public async Task<string> GetAccessToken()
+        {
+            (bool cliSucceeded, string cliToken) = await TryGetAzCliToken();
+
+            if (cliSucceeded) return cliToken;
+
+            throw new Exception("Unable to connect to Azure. Make sure you have the `az` CLI or Azure PowerShell installed and logged in and try again");
+        }
+
+        private async Task<(bool succeeded, string token)> TryGetAzCliToken()
+        {
+            var az = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
+                ? new Executable("cmd", "/c az " + Constants.azParameters)
+                : new Executable("az", Constants.azParameters);
+
+            var stdout = new StringBuilder();
+            var stderr = new StringBuilder();
+            var completed = az.RunAsync(o => stdout.AppendLine(o), e => stderr.AppendLine(e));
+
+            if (await completed == 0)
+                return (true, stdout.ToString().Trim(' ', '\n', '\r', '"'));            
+            else
+            {
+                ColoredConsole.WriteLine(($"Unable to fetch access token from az cli. Error: {stderr.ToString().Trim(' ', '\n', '\r')}"));
+                return (false, stdout.ToString().Trim(' ', '\n', '\r', '"'));
+            }
+        }
+
+    }
+
+}

src/apimtemplate/Program.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Threading.Tasks;
 using Colors.Net;
 using McMaster.Extensions.CommandLineUtils;
 
@@ -16,7 +15,7 @@ class Program
         public static int Main(string[] args)
         {
             try
-            {   
+            {
                 var app = new CommandLineApplication() 
                 {
                     Name = Constants.AppShortName,
@@ -30,7 +29,7 @@ public static int Main(string[] args)
 
                 app.OnExecute(() => {
                     ColoredConsole.Error.WriteLine("No commands specified, please specify a command");
-                    app.ShowHelp();
+                    app.ShowHelp();                    
                     return 1;
                 });
 
@@ -39,8 +38,11 @@ public static int Main(string[] args)
             catch (Exception e)
             {
                 ColoredConsole.Error.WriteLine(e.Message);
+                Console.ReadKey();
                 return 1;
             }
         }
+
+
     }
 }