support for connection strings with client credentials

MSDYNV9/Xrm.Framework.CI/Xrm.Framework.CI.Common/OAuthClientCredentialsHook.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using Microsoft.IdentityModel.Clients.ActiveDirectory;
+using Microsoft.Xrm.Tooling.Connector;
+
+namespace Xrm.Framework.CI.Common
+{
+
+    public class OAuthClientCredentialsHook : IOverrideAuthHookWrapper
+    {
+        private readonly ConcurrentDictionary<Uri, AuthenticationParameters> authenticationParameters =
+            new ConcurrentDictionary<Uri, AuthenticationParameters>();
+
+        private readonly Dictionary<string, AuthenticationResult> authenticationResults =
+            new Dictionary<string, AuthenticationResult>();
+
+        private readonly string clientSecret;
+        private readonly string clientId;
+
+        public OAuthClientCredentialsHook(string clientId, string clientSecret)
+        {
+            this.clientId = clientId;
+            this.clientSecret = clientSecret;
+        }
+
+        public string GetAuthToken(Uri connectedUri)
+        {
+            if (!authenticationResults.ContainsKey(connectedUri.Host) ||
+                authenticationResults[connectedUri.Host].ExpiresOn < DateTime.UtcNow.AddSeconds(30))
+            {
+                var parameters = authenticationParameters.GetOrAdd(GetWebApiUri(connectedUri), GetAuthenticationParameters);
+                authenticationResults[connectedUri.Host] = GetAccessToken(parameters);
+            }
+
+            return authenticationResults[connectedUri.Host].AccessToken;
+        }
+
+        private AuthenticationResult GetAccessToken(AuthenticationParameters authParameters)
+        {
+            var authContext = new AuthenticationContext(authParameters.Authority, false);
+            return authContext.AcquireTokenAsync(authParameters.Resource, new ClientCredential(clientId, clientSecret)).Result;
+        }
+
+        private Uri GetWebApiUri(Uri uri) =>
+            new Uri(uri.GetLeftPart(UriPartial.Authority) + "/api/data/v9.1/");
+
+        private AuthenticationParameters GetAuthenticationParameters(Uri webApiUri) =>
+            AuthenticationParameters.CreateFromResourceUrlAsync(webApiUri).Result;
+    }
+}

MSDYNV9/Xrm.Framework.CI/Xrm.Framework.CI.Common/ParsedConnectionString.cs

@@ -0,0 +1,87 @@
+using Microsoft.Xrm.Tooling.Connector;
+using System;
+
+namespace Xrm.Framework.CI.Common
+{
+    internal class ParsedConnectionString
+    {
+        public InternalAuthenticationType AuthType { get; private set; }
+        public bool RequireNewInstance { get; private set; }
+        public string ClientSecret { get; private set; }
+        public string ClientId { get; private set; }
+        public Uri Server { get; private set; }
+
+        public ParsedConnectionString(string connectionString)
+        {
+            RequireNewInstance = GetRequireNewInstance(connectionString);
+            ClientSecret = GetClientSecret(connectionString);
+            ClientId = GetClientId(connectionString);
+            AuthType = GetAuthType(connectionString);
+            var server = GetServerString(connectionString);
+
+            if (!Uri.IsWellFormedUriString(server, UriKind.Absolute))
+            {
+                throw new ArgumentException(nameof(Server));
+            }
+
+            Server = new Uri(server);
+
+            if (AuthType != InternalAuthenticationType.S2S)
+            {
+                return;
+            }
+
+            if (string.IsNullOrWhiteSpace(ClientId))
+            {
+                throw new ArgumentException(nameof(ClientId));
+            }
+
+            if (string.IsNullOrWhiteSpace(ClientSecret))
+            {
+                throw new ArgumentException(nameof(ClientSecret));
+            }
+        }
+
+        private static InternalAuthenticationType GetAuthType(string connectionString) =>
+            Enum.TryParse(connectionString
+                .ToDictionary()
+                .FirstNotNullOrEmpty(nameof(AuthType)), true, out InternalAuthenticationType result) ? result : InternalAuthenticationType.AD;
+
+        private static string GetClientId(string connectionString) =>
+            connectionString
+                .ToDictionary()
+                .FirstNotNullOrEmpty(nameof(ClientId));
+
+        private static string GetClientSecret(string connectionString) =>
+            connectionString
+                .ToDictionary()
+                .FirstNotNullOrEmpty(nameof(ClientSecret));
+
+        private static bool GetRequireNewInstance(string connectionString) =>
+            bool.TryParse(connectionString
+                .ToDictionary()
+                .FirstNotNullOrEmpty(nameof(RequireNewInstance)), out bool result) && result;
+
+        private static string GetServerString(string connectionString) =>
+            connectionString
+                .ToDictionary()
+                .FirstNotNullOrEmpty("ServiceUri", "Service Uri", "Url", nameof(Server));
+
+        private static Uri GetServer(string connectionString) =>
+            new Uri(GetServerString(connectionString));
+    }
+
+    internal enum InternalAuthenticationType
+    {
+        InvalidConnection = -1,
+        AD = 0,
+        Live = 1,
+        IFD = 2,
+        Claims = 3,
+        Office365 = 4,
+        OAuth = 5,
+        Certificate = 6,
+        ExternalTokenManagement = 99, // 0x00000063
+        S2S
+    }
+}

MSDYNV9/Xrm.Framework.CI/Xrm.Framework.CI.Common/Xrm.Framework.CI.Common.csproj

@@ -86,11 +86,13 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="AsyncOperationManager.cs" />
+    <Compile Include="ParsedConnectionString.cs" />
     <Compile Include="Data\ConfigDataManager.cs" />
     <Compile Include="Entities\Entities.cs" />
     <Compile Include="Entities\OptionSets.cs" />
     <Compile Include="ImportJobManager.cs" />
     <Compile Include="Logging\ILogger.cs" />
+    <Compile Include="OAuthClientCredentialsHook.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="SolutionManagement\SolutionComponentsManager.cs" />
     <Compile Include="Workflows\WorkflowFixer.cs" />

MSDYNV9/Xrm.Framework.CI/Xrm.Framework.CI.Common/XrmConnectionManager.cs

@@ -1,13 +1,9 @@
 using Microsoft.Xrm.Sdk;
 using Microsoft.Xrm.Tooling.Connector;
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Net;
-using System.Reflection;
-using System.Text;
 using System.Threading;
-using System.Threading.Tasks;
+
 using Xrm.Framework.CI.Common.Logging;
 
 namespace Xrm.Framework.CI.Common
@@ -69,13 +65,26 @@ private void SetSecurityProtocol()
 
         private IOrganizationService ConnectToCRM(string connectionString, int timeout)
         {
-            CrmServiceClient.MaxConnectionTimeout = TimeSpan.FromMinutes(timeout == 0 ? DefaultTime : timeout);
+            var parsedConnectionString = new ParsedConnectionString(connectionString);
+            Logger.LogVerbose("ConnectionString info - AuthType = {0}, Server = {1}", parsedConnectionString.AuthType, parsedConnectionString.Server);
+            if (parsedConnectionString.AuthType == InternalAuthenticationType.S2S)
+            {
+                CrmServiceClient.AuthOverrideHook = new OAuthClientCredentialsHook(parsedConnectionString.ClientId, parsedConnectionString.ClientSecret);
+            }
 
+            CrmServiceClient.MaxConnectionTimeout = TimeSpan.FromMinutes(timeout == 0 ? DefaultTime : timeout);
             CrmServiceClient serviceClient = null;
             for (int i = 1; i <= ConnectRetryCount; i++)
             {
                 Logger.LogVerbose("Connecting to CRM [attempt {0}]", i);
-                serviceClient = new CrmServiceClient(connectionString);
+                if (parsedConnectionString.AuthType == InternalAuthenticationType.S2S)
+                {
+                    serviceClient = new CrmServiceClient(parsedConnectionString.Server, parsedConnectionString.RequireNewInstance);
+                }
+                else
+                {
+                    serviceClient = new CrmServiceClient(connectionString);
+                }
 
                 if (serviceClient != null && serviceClient.IsReady)
                 {