moved classes to separate files

Author: fearthecowboy

src/Accounts/Accounts/CommonModule/ContextAdapter.cs

@@ -0,0 +1,103 @@
+// ----------------------------------------------------------------------------------
+//
+// Copyright Microsoft Corporation
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ----------------------------------------------------------------------------------
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Net.Http;
+using System.Collections.Generic;
+using Microsoft.Azure.Commands.Common.Authentication.Abstractions;
+using Microsoft.Azure.Commands.Common.Authentication.Abstractions.Core;
+using Microsoft.Azure.Commands.Profile.Models;
+using System.Globalization;
+using Microsoft.Azure.Commands.Common.Authentication;
+
+namespace Microsoft.Azure.Commands.Common
+{
+  using NextDelegate = Func<HttpRequestMessage, CancellationToken, Action, Func<string, CancellationToken, Func<EventArgs>, Task>, Task<HttpResponseMessage>>;
+  using SignalDelegate = Func<string, CancellationToken, Func<EventArgs>, Task>;
+  using PipelineChangeDelegate = Action<Func<HttpRequestMessage, CancellationToken, Action, Func<string, CancellationToken, Func<EventArgs>, Task>, Func<HttpRequestMessage, CancellationToken, Action, Func<string, CancellationToken, Func<EventArgs>, Task>, Task<HttpResponseMessage>>, Task<HttpResponseMessage>>>;
+
+  internal class ContextAdapter
+    {
+        IProfileProvider _provider = AzureRmProfileProvider.Instance;
+        IAuthenticationFactory _authenticator = AzureSession.Instance.AuthenticationFactory;
+
+        internal static ContextAdapter Instance => new ContextAdapter();
+
+        public void OnNewRequest(Dictionary<string, object> boundParameters, PipelineChangeDelegate prependStep, PipelineChangeDelegate appendStep)
+        {
+            appendStep(this.SendHandler(GetDefaultContext(_provider, boundParameters), AzureEnvironment.Endpoint.ResourceManager));
+        }
+
+        public object GetParameterValue(string resourceId, string moduleName, Dictionary<string, object> boundParameters, string name)
+        {
+            var defaultContext = GetDefaultContext(_provider, boundParameters);
+            var endpoint = GetDefaultEndpoint(defaultContext, AzureEnvironment.Endpoint.ResourceManager);
+            switch (name)
+            {
+                case "subscriptionId":
+                    return defaultContext?.Subscription?.Id;
+                case "host":
+                    return endpoint?.Host;
+                case "port":
+                    return endpoint?.Port;
+            }
+
+            return string.Empty;
+        }
+
+        static IAzureContext GetDefaultContext(IProfileProvider provider, Dictionary<string, object> boundParameters)
+        {
+            IAzureContextContainer context;
+            var contextConverter = new AzureContextConverter();
+            if (boundParameters.ContainsKey("DefaultContext")
+                && contextConverter.CanConvertFrom(boundParameters["DefaultContext"], typeof(IAzureContextContainer)))
+            {
+                context = contextConverter.ConvertFrom(boundParameters["DefaultContext"], typeof(IAzureContextContainer), CultureInfo.InvariantCulture, true) as IAzureContextContainer;
+            }
+            else
+            {
+                context = provider.Profile;
+            }
+
+            return context?.DefaultContext;
+        }
+
+        static Uri GetDefaultEndpoint(IAzureContext context, string endpointName = AzureEnvironment.Endpoint.ResourceManager)
+        {
+            var environment = context?.Environment ?? AzureEnvironment.PublicEnvironments[EnvironmentName.AzureCloud];
+            return environment.GetEndpointAsUri(endpointName);
+        }
+
+        internal Func<HttpRequestMessage, CancellationToken, Action, SignalDelegate, NextDelegate, Task<HttpResponseMessage>> SendHandler(IAzureContext context, string resourceId)
+        {
+            return async (request, cancelToken, cancelAction, signal, next) =>
+            {
+                await AuthorizeRequest(context, resourceId, request, cancelToken);
+                return await next(request, cancelToken, cancelAction, signal);
+            };
+        }
+
+        internal async Task AuthorizeRequest(IAzureContext context, string resourceId, HttpRequestMessage request, CancellationToken outerToken)
+        {
+            await Task.Run(() =>
+            {
+                var authToken = _authenticator.Authenticate(context.Account, context.Environment, context.Tenant.Id, null, "Never", null, resourceId);
+                authToken.AuthorizeRequest((type, token) => request.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue(type, token));
+            }, outerToken);
+        }
+    }
+
+}

src/Accounts/Accounts/CommonModule/EventData.cs

@@ -18,64 +18,21 @@
 using System.ComponentModel;
 using System.Diagnostics.Tracing;
 using System.Net.Http;
-using System.Threading;
 using System.Threading.Tasks;
-using GetEventData = System.Func<Microsoft.Azure.Commands.Common.EventData>;
 
 
 namespace Microsoft.Azure.Commands.Common
 {
 
 
-    using EventListenerDelegate = Func<EventData, Task>;
-    using GetParameterDelegate = Func<string, Dictionary<string, object>, string, object>;
-    using SendAsyncStep = Func<HttpRequestMessage, IEventListener, ISendAsync, Task<HttpResponseMessage>>;
-    using PipelineChangeDelegate = Action<EventData>;
+  using EventListenerDelegate = Func<EventData, Task>;
+  using GetParameterDelegate = Func<string, Dictionary<string, object>, string, object>;
+  using SendAsyncStep = Func<HttpRequestMessage, IEventListener, ISendAsync, Task<HttpResponseMessage>>;
+  using PipelineChangeDelegate = Action<EventData>;
 
-    /// <summary>
-    /// The IEventListener Interface defines the communication mechanism for Signaling events during a remote call.
-    /// </summary>
-    /// <remarks>
-    /// The interface is designed to be as minimal as possible, allow for quick peeking of the event type (<c>id</c>) 
-    /// and the cancellation status and provides a delegate for retrieving the event details themselves.
-    /// </remarks>
-    public interface IEventListener
-    {
-        Task Signal(string id, CancellationToken token, GetEventData createMessage);
-        CancellationToken Token { get; }
-        System.Action Cancel { get; }
-    }
-
-    public class Response : EventData
-    {
-        public Response() : base()
-        {
-        }
-    }
-
-    public class Response<T> : Response
-    {
-        private Func<Task<T>> _resultDelegate;
-        private Task<T> _resultValue;
-
-        public Response(T value) : base() => _resultValue = Task.FromResult(value);
-        public Response(Func<T> value) : base() => _resultDelegate = () => Task.FromResult(value());
-        public Response(Func<Task<T>> value) : base() => _resultDelegate = value;
-        public Task<T> Result => _resultValue ?? (_resultValue = this._resultDelegate());
-    }
-
-
-    /// <summary>
-    /// The interface for sending an HTTP request across the wire.
-    /// </summary>
-    public interface ISendAsync
-    {
-        Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, IEventListener callback);
-    }
 
 
-
-    [TypeConverter(typeof(EventDataConverter))]
+  [TypeConverter(typeof(EventDataConverter))]
     ///	<remarks>
     /// In PowerShell, we add on the EventDataConverter to support sending events between modules.
     /// Obviously, this code would need to be duplcated on both modules.
@@ -135,6 +92,38 @@ public partial class EventData : EventArgs
         /// </summary>
         public object ResponseMessage;
 
+        /// <summary> 
+        /// The name of the cmdlet that is being executed
+        /// </summary> 
+        public string CmdletName;
+        
+        /// <summary> 
+        /// Correlation Id for cmdlet invocation
+        /// </summary> 
+        public string CmdletInvocationId;
+        
+        /// <summary> 
+        /// 
+        /// </summary> 
+        public string ProcessRecordId;
+
+        /// <summary> 
+        /// 
+        /// </summary> 
+        public string ParameterSet;
+
+        /// <summary> 
+        /// 
+        /// </summary> 
+        public string RequestCorrelationId;
+
+        /// <summary> 
+        /// The 'this.MyInvocation.BoundParameters' from the cmdlet 
+        /// </summary> 
+        public System.Collections.Generic.IDictionary<string,object> BoundParamters;
+
+        public System.Exception Exception;
+
         /// <summary>
         /// Cancellation method for this event. 
         /// 
@@ -146,81 +135,4 @@ public partial class EventData : EventArgs
         public System.Action Cancel;
     }
 
-    /// <summary>
-    /// A PowerShell PSTypeConverter to adapt an <c>EventData</c> object that has been passed.
-    /// Usually used between modules.
-    /// </summary>
-    public class EventDataConverter : System.Management.Automation.PSTypeConverter
-    {
-        public override bool CanConvertTo(object sourceValue, Type destinationType) => false;
-        public override object ConvertTo(object sourceValue, Type destinationType, IFormatProvider formatProvider, bool ignoreCase) => null;
-        public override bool CanConvertFrom(dynamic sourceValue, Type destinationType) => destinationType == typeof(EventData) && CanConvertFrom(sourceValue);
-        public override object ConvertFrom(dynamic sourceValue, Type destinationType, IFormatProvider formatProvider, bool ignoreCase) => ConvertFrom(sourceValue);
-
-        public static bool CanConvertFrom(dynamic sv)
-        {
-            var result = true;
-            try
-            {
-                // check if this has required parameters...
-                sv?.Id?.GetType();
-                sv?.Message?.GetType();
-                sv?.Parameter?.GetType();
-                sv?.Value?.GetType();
-                sv?.RequestMessage?.GetType();
-                sv?.ResponseMessage?.GetType();
-                sv?.Cancel?.GetType();
-            }
-            catch
-            {
-                return false;
-            }
-            return result;
-        }
-
-        public static EventData ConvertFrom(dynamic sv)
-        {
-            try
-            {
-                return new EventData
-                {
-                    Id = sv.Id,
-                    Message = sv.Message,
-                    Parameter = sv.Parameter,
-                    Value = sv.Value,
-                    RequestMessage = sv.RequestMessage,
-                    ResponseMessage = sv.ResponseMessage,
-                    Cancel = sv.Cancel
-                };
-            }
-            catch
-            {
-            }
-            return null;
-        }
-    }
-    public static class Events
-    {
-        public const string Log = nameof(Log);
-        public const string Validation = nameof(Validation);
-        public const string ValidationWarning = nameof(ValidationWarning);
-        public const string AfterValidation = nameof(AfterValidation);
-        public const string RequestCreated = nameof(RequestCreated);
-        public const string ResponseCreated = nameof(ResponseCreated);
-        public const string URLCreated = nameof(URLCreated);
-        public const string Finally = nameof(Finally);
-        public const string HeaderParametersAdded = nameof( HeaderParametersAdded);
-        public const string BodyContentSet = nameof( BodyContentSet);
-        public const string BeforeCall = nameof( BeforeCall);
-        public const string BeforeResponseDispatch = nameof( BeforeResponseDispatch);
-        public const string CmdletProcessRecordStart = nameof(CmdletProcessRecordStart);
-        public const string CmdletException = nameof(CmdletException);
-        public const string CmdletGetPipeline = nameof(CmdletGetPipeline);
-        public const string CmdletBeforeAPICall = nameof(CmdletBeforeAPICall);
-        public const string CmdletAfterAPICall =  nameof(CmdletAfterAPICall);
-        public const string FollowingNextLink = nameof(FollowingNextLink);
-        public const string DelayBeforePolling = nameof(DelayBeforePolling);
-        public const string Polling = nameof(Polling);
-    }
-
 }

src/Accounts/Accounts/CommonModule/EventDataConverter.cs

@@ -0,0 +1,78 @@
+// ----------------------------------------------------------------------------------
+//
+// Copyright Microsoft Corporation
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ----------------------------------------------------------------------------------
+
+
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Threading.Tasks;
+
+
+namespace Microsoft.Azure.Commands.Common
+{
+  /// <summary>
+  /// A PowerShell PSTypeConverter to adapt an <c>EventData</c> object that has been passed.
+  /// Usually used between modules.
+  /// </summary>
+  public class EventDataConverter : System.Management.Automation.PSTypeConverter
+    {
+        public override bool CanConvertTo(object sourceValue, Type destinationType) => false;
+        public override object ConvertTo(object sourceValue, Type destinationType, IFormatProvider formatProvider, bool ignoreCase) => null;
+        public override bool CanConvertFrom(dynamic sourceValue, Type destinationType) => destinationType == typeof(EventData) && CanConvertFrom(sourceValue);
+        public override object ConvertFrom(dynamic sourceValue, Type destinationType, IFormatProvider formatProvider, bool ignoreCase) => ConvertFrom(sourceValue);
+
+        public static bool CanConvertFrom(dynamic sv)
+        {
+            var result = true;
+            try
+            {
+                // check if this has required parameters...
+                sv?.Id?.GetType();
+                sv?.Message?.GetType();
+                sv?.Parameter?.GetType();
+                sv?.Value?.GetType();
+                sv?.RequestMessage?.GetType();
+                sv?.ResponseMessage?.GetType();
+                sv?.Cancel?.GetType();
+            }
+            catch
+            {
+                return false;
+            }
+            return result;
+        }
+
+        public static EventData ConvertFrom(dynamic sv)
+        {
+            try
+            {
+                return new EventData
+                {
+                    Id = sv.Id,
+                    Message = sv.Message,
+                    Parameter = sv.Parameter,
+                    Value = sv.Value,
+                    RequestMessage = sv.RequestMessage,
+                    ResponseMessage = sv.ResponseMessage,
+                    Cancel = sv.Cancel
+                };
+            }
+            catch
+            {
+            }
+            return null;
+        }
+    }
+
+}