Imported Upstream version 4.0.0~alpha1

Former-commit-id: 806294f5ded97629b74c85c09952f2a74fe182d9

external/referencesource/System.Workflow.Runtime/Hosting/DbResourceAllocator.cs

@@ -0,0 +1,380 @@
+//------------------------------------------------------------------------------
+// <copyright file="DbResourceAllocator.cs" company="Microsoft">
+//   Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+#region Using directives
+
+using System;
+using System.Collections.Specialized;
+using System.Configuration;
+using System.Data;
+using System.Data.Common;
+using System.Data.OleDb;
+using System.Data.SqlClient;
+using System.Diagnostics;
+using System.Globalization;
+using System.Text.RegularExpressions;
+using System.Transactions;
+using System.Threading;
+
+#endregion
+
+namespace System.Workflow.Runtime.Hosting
+{
+    /// <summary>
+    /// Local database providers we support
+    /// </summary>
+    internal enum Provider
+    {
+        SqlClient = 0,
+        OleDB = 1
+    }
+
+    /// <summary>
+    /// Internal Database access abstraction to 
+    /// - abstract the derived Out-of-box SharedConnectionInfo from all DB hosting services
+    /// - provide uniform connection string management
+    /// - and support different database providers 
+    /// </summary>
+    internal sealed class DbResourceAllocator
+    {
+        const string EnlistFalseToken = ";Enlist=false";
+        internal const string ConnectionStringToken = "ConnectionString";
+
+        string connString;
+        Provider localProvider;
+
+        /// <summary>
+        /// Initialize the object by getting the connection string from the parameter or 
+        /// out of the configuration settings
+        /// </summary>
+        /// <param name="runtime"></param>
+        /// <param name="parameters"></param>
+        /// <param name="connectionString"></param>
+        internal DbResourceAllocator(
+            WorkflowRuntime runtime,
+            NameValueCollection parameters,
+            string connectionString)
+        {
+            // If connection string not specified in input, search the config sections
+            if (String.IsNullOrEmpty(connectionString))
+            {
+                if (parameters != null)
+                {
+                    // First search in this service's parameters
+                    foreach (string key in parameters.AllKeys)
+                    {
+                        if (string.Compare(ConnectionStringToken, key, StringComparison.OrdinalIgnoreCase) == 0)
+                        {
+                            connectionString = parameters[ConnectionStringToken];
+                            break;
+                        }
+                    }
+                }
+                if (String.IsNullOrEmpty(connectionString) && (runtime != null))
+                {
+                    NameValueConfigurationCollection commonConfigurationParameters = runtime.CommonParameters;
+                    if (commonConfigurationParameters != null)
+                    {
+                        // Then scan for connection string in the common configuration parameters section
+                        foreach (string key in commonConfigurationParameters.AllKeys)
+                        {
+                            if (string.Compare(ConnectionStringToken, key, StringComparison.OrdinalIgnoreCase) == 0)
+                            {
+                                connectionString = commonConfigurationParameters[ConnectionStringToken].Value;
+                                break;
+                            }
+                        }
+                    }
+                }
+
+                // If no connectionString parsed out of the params, inner layer throws 
+                //   System.ArgumentNullException: Connection string cannot be null or empty
+                //   Parameter name: connectionString
+                // But this API caller does not have connectionString param.
+                // So throw ArgumentException with the original message.
+                if (String.IsNullOrEmpty(connectionString))
+                    throw new ArgumentNullException(ConnectionStringToken, ExecutionStringManager.MissingConnectionString);
+            }
+
+            Init(connectionString);
+        }
+
+        #region Accessors
+
+        internal string ConnectionString
+        {
+            get { return this.connString; }
+        }
+
+        #endregion Accessors
+
+
+        #region Internal Methods
+        /// <summary>
+        /// Disallow the hosting service to have different connection string if using SharedConnectionWorkflowTransactionService
+        /// Should be called after all hosting services are added to the WorkflowRuntime
+        /// </summary>
+        /// <param name="transactionService"></param>
+        internal void DetectSharedConnectionConflict(WorkflowCommitWorkBatchService transactionService)
+        {
+            SharedConnectionWorkflowCommitWorkBatchService sharedConnectionTransactionService = transactionService as SharedConnectionWorkflowCommitWorkBatchService;
+            if (sharedConnectionTransactionService != null)
+            {
+                if (String.Compare(sharedConnectionTransactionService.ConnectionString, this.connString, StringComparison.Ordinal) != 0)
+                    throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,
+                        ExecutionStringManager.SharedConnectionStringSpecificationConflict, this.connString, sharedConnectionTransactionService.ConnectionString));
+            }
+
+        }
+
+        #region Get a connection
+
+        internal DbConnection OpenNewConnection()
+        {
+            // Always disallow AutoEnlist since we enlist explicitly when necessary
+            return OpenNewConnection(true);
+        }
+
+        internal DbConnection OpenNewConnectionNoEnlist()
+        {
+            return OpenNewConnection(true);
+        }
+
+        internal DbConnection OpenNewConnection(bool disallowEnlist)
+        {
+            DbConnection connection = null;
+            string connectionStr = this.connString;
+
+            if (disallowEnlist)
+                connectionStr += DbResourceAllocator.EnlistFalseToken;
+
+            if (this.localProvider == Provider.SqlClient)
+                connection = new SqlConnection(connectionStr);
+            else
+                connection = new OleDbConnection(connectionStr);
+
+            connection.Open();
+
+            return connection;
+        }
+
+        /// <summary>
+        /// Gets a connection enlisted to the transaction.  
+        /// If the transaction already has a connection attached to it, we return that,
+        /// otherwise we create a new connection and enlist to the transaction
+        /// </summary>
+        /// <param name="transaction"></param>
+        /// <param name="isNewConnection">output if we created a connection</param>
+        /// <returns></returns>
+        internal DbConnection GetEnlistedConnection(WorkflowCommitWorkBatchService txSvc, Transaction transaction, out bool isNewConnection)
+        {
+            DbConnection connection;
+            SharedConnectionInfo connectionInfo = GetConnectionInfo(txSvc, transaction);
+
+            if (connectionInfo != null)
+            {
+                connection = connectionInfo.DBConnection;
+                Debug.Assert((connection != null), "null connection");
+                Debug.Assert((connection.State == System.Data.ConnectionState.Open),
+                    "Invalid connection state " + connection.State + " for connection " + connection);
+
+                isNewConnection = false;
+            }
+            else
+            {
+                connection = this.OpenNewConnection();
+                connection.EnlistTransaction(transaction);
+
+                isNewConnection = true;
+            }
+
+            return connection;
+        }
+
+        #endregion Get a connection
+
+        #region Get Local Transaction
+
+        internal static DbTransaction GetLocalTransaction(WorkflowCommitWorkBatchService txSvc, Transaction transaction)
+        {
+            DbTransaction localTransaction = null;
+            SharedConnectionInfo connectionInfo = GetConnectionInfo(txSvc, transaction);
+
+            if (connectionInfo != null)
+                localTransaction = connectionInfo.DBTransaction;
+
+            return localTransaction;
+        }
+
+        #endregion Get Local Transaction
+
+        #region Get a command object for querying
+
+        internal DbCommand NewCommand()
+        {
+            DbConnection dbConnection = OpenNewConnection();
+            return DbResourceAllocator.NewCommand(dbConnection);
+        }
+
+        internal static DbCommand NewCommand(DbConnection dbConnection)
+        {
+            return NewCommand(null, dbConnection, null);
+        }
+        internal static DbCommand NewCommand(string commandText, DbConnection dbConnection, DbTransaction transaction)
+        {
+            DbCommand command = dbConnection.CreateCommand();
+            command.CommandText = commandText;
+            command.Transaction = transaction;
+
+            return command;
+        }
+
+        #endregion Get a command object for querying
+
+        #region build a command parameter object for a stored procedure
+
+        internal DbParameter NewDbParameter()
+        {
+            return NewDbParameter(null, null);
+        }
+
+        internal DbParameter NewDbParameter(string parameterName, DbType type)
+        {
+            if (this.localProvider == Provider.SqlClient)
+            {
+                if (type == DbType.Int64)
+                    return new SqlParameter(parameterName, SqlDbType.BigInt);
+                else
+                    return new SqlParameter(parameterName, type);
+            }
+            else
+            {
+
+                if (type == DbType.Int64)
+                    return new OleDbParameter(parameterName, OleDbType.BigInt);
+                else
+                    return new OleDbParameter(parameterName, type);
+            }
+        }
+
+        internal DbParameter NewDbParameter(string parameterName, DbType type, ParameterDirection direction)
+        {
+            DbParameter parameter = NewDbParameter(parameterName, type);
+            parameter.Direction = direction;
+
+            return parameter;
+        }
+
+        internal DbParameter NewDbParameter(string parameterName, object value)
+        {
+            if (this.localProvider == Provider.SqlClient)
+                return new SqlParameter(parameterName, value);
+            else
+                return new OleDbParameter(parameterName, value);
+        }
+
+        #endregion build a command parameter object for a stored procedure
+
+        #endregion Public Methods
+
+
+        #region Private Helpers
+
+        private void Init(string connectionStr)
+        {
+            SetConnectionString(connectionStr);
+
+            try
+            {
+                // Open a connection to see if it's a valid connection string
+                using (DbConnection connection = this.OpenNewConnection(false))
+                {
+                }
+            }
+            catch (Exception e)
+            {
+                throw new ArgumentException(ExecutionStringManager.InvalidDbConnection, "connectionString", e);
+            }
+
+            // OLEDB connection pooling causes this exception in ExecuteInsertWorkflowInstance
+            // "Cannot start more transactions on this session."
+            // Disable pooling to avoid dirty connections.
+            if (this.localProvider == Provider.OleDB)
+                this.connString = String.Concat(this.connString, ";OLE DB Services=-4");
+        }
+
+        private void SetConnectionString(string connectionString)
+        {
+            if (String.IsNullOrEmpty(connectionString) || String.IsNullOrEmpty(connectionString.Trim()))
+                throw new ArgumentNullException("connectionString", ExecutionStringManager.MissingConnectionString);
+
+            DbConnectionStringBuilder dcsb = new DbConnectionStringBuilder();
+            dcsb.ConnectionString = connectionString;
+
+            // Don't allow the client to specify an auto-enlist value since we decide whether to participate in a transaction
+            // (enlist for writing and not for reading).
+            if (dcsb.ContainsKey("enlist"))
+            {
+                throw new ArgumentException(ExecutionStringManager.InvalidEnlist);
+            }
+
+            this.connString = connectionString;
+            //
+            // We only support sqlclient, sql is the only data store our OOB services talk to.
+            localProvider = Provider.SqlClient;
+        }
+        /*
+        private void SetLocalProvider(string connectionString)
+        {
+            // Assume caller already validated the connection string
+            MatchCollection providers = Regex.Matches(connectionString, @"(^|;)\s*provider\s*=[^;$]*(;|$)", RegexOptions.IgnoreCase);
+
+            // Cannot use DbConnectionStringBuilder because it selects the last provider, not the first one, by itself.
+            // A legal Sql connection string allows for multiple provider specification and 
+            // selects the first provider
+            if (providers.Count > 0)
+            {
+                // Check if the first one matches "sqloledb" or "sqloledb.<digit>"
+                if (Regex.IsMatch(providers[0].Value, @"provider\s*=\s*sqloledb(\.\d+)?\s*(;|$)", RegexOptions.IgnoreCase))
+                {
+                    this.localProvider = Provider.OleDB;
+                }
+                else
+                {
+                    // We don't support other providers
+                    throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,ExecutionStringManager.UnsupportedSqlProvider, providers[0].Value));
+                }
+            }
+            else
+            {
+                // SqlClient provider requires no provider keyword specified in connection string
+                this.localProvider = Provider.SqlClient;
+            }
+        }
+        */
+
+        private static SharedConnectionInfo GetConnectionInfo(WorkflowCommitWorkBatchService txSvc, Transaction transaction)
+        {
+            SharedConnectionInfo connectionInfo = null;
+
+            SharedConnectionWorkflowCommitWorkBatchService scTxSvc = txSvc as SharedConnectionWorkflowCommitWorkBatchService;
+            if (scTxSvc != null)
+            {
+                connectionInfo = scTxSvc.GetConnectionInfo(transaction);
+
+                // The transaction service can't find entry if the transaction has been completed.
+                // be sure to propate the error so durable services can cast to appropriate exception
+                if (connectionInfo == null)
+                    throw new ArgumentException(
+                        String.Format(CultureInfo.CurrentCulture, ExecutionStringManager.InvalidTransaction));
+            }
+            return connectionInfo;
+        }
+
+        #endregion Private Helpers
+    }
+
+}