public SqlRetryPolicyProviderManager(SqlRetryPolicyProviderConfigurationSection configSection)
{
_typeName = GetType().Name;
_providers = new ConcurrentDictionary <SqlRetryLogicMethod, SqlRetryPolicyProvider>();
var retryLogicWithAppSpecifiedProvider = new HashSet <SqlRetryLogicMethod>();
_retryLogicWithAppSpecifiedProvider = retryLogicWithAppSpecifiedProvider;
if (configSection == null)
{
return;
}
if (!string.IsNullOrEmpty(configSection.InitializerType))
{
try
{
var initializerType = Type.GetType(configSection.InitializerType, true);
_initializer = (SqlRetryLogicInitializer)Activator.CreateInstance(initializerType);
_initializer.Initialize();
}
catch (Exception e)
{
throw SQL.CannotCreateSqlAuthInitializer(configSection.InitializerType, e);
}
}
//// add user-defined providers, if any.
////
if (configSection.Providers != null && configSection.Providers.Count > 0)
{
foreach (ProviderSettings providerSettings in configSection.Providers)
{
SqlRetryLogicMethod retrylogicmethod = RetryLogicEnumFromString(providerSettings.Name);
SqlRetryPolicyProvider provider;
try
{
var providerType = Type.GetType(providerSettings.Type, true);
provider = (SqlRetryPolicyProvider)Activator.CreateInstance(providerType);
}
catch (Exception e)
{
throw SQL.CannotCreateAuthProvider(retrylogicmethod.ToString(), providerSettings.Type, e);
}
if (!provider.IsSupported(retrylogicmethod))
{
throw SQL.UnsupportedAuthenticationByProvider(retrylogicmethod.ToString(), providerSettings.Type);
}
_providers[retrylogicmethod] = provider;
retryLogicWithAppSpecifiedProvider.Add(retrylogicmethod);
}
}
}
/// <summary>
/// Set an authentication provider by method.
/// </summary>
/// <param name="provider">Authentication provider.</param>
/// <param name="sqlRetryLogicMethod">Authentication provider.</param>
/// <returns>True if succeeded, false otherwise, e.g., the existing provider disallows overriding.</returns>
public bool SetProvider(SqlRetryPolicyProvider provider, SqlRetryLogicMethod sqlRetryLogicMethod)
{
if (!provider.IsSupported(sqlRetryLogicMethod))
{
throw SQL.UnsupportedAuthenticationByProvider("", provider.GetType().Name);
}
_providers.AddOrUpdate(sqlRetryLogicMethod, provider, (key, oldProvider) =>
{
if (oldProvider != null)
{
oldProvider.BeforeUnload(sqlRetryLogicMethod);
}
if (provider != null)
{
provider.BeforeLoad(sqlRetryLogicMethod);
}
return(provider);
});
return(true);
}
public override bool IsSupported(SqlRetryLogicMethod retrylogicmethod)
{
// Supported for Connection Open and Command Execution scenarios
return((retrylogicmethod == SqlRetryLogicMethod.ConnectionOpen) || (retrylogicmethod == SqlRetryLogicMethod.CommandExecution));
}
/// <summary> /// /// </summary> /// <param name="reliabilityMethod"></param> /// <returns></returns> public abstract bool IsSupported(SqlRetryLogicMethod reliabilityMethod);
/// <summary>
///
/// </summary>
/// <param name="reliabilityMethod"></param>
public virtual void BeforeUnload(SqlRetryLogicMethod reliabilityMethod)
{
}
/// <summary>
///
/// </summary>
/// <param name="reliabilityMethod"></param>
/// <param name="provider"></param>
/// <returns></returns>
public static bool SetProvider(SqlRetryLogicMethod reliabilityMethod, SqlRetryPolicyProvider provider)
{
return(SqlRetryPolicyProviderManager.Instance.SetProvider(provider, reliabilityMethod));
}
/// <summary>
///
/// </summary>
/// <param name="reliabilityMethod"></param>
/// <returns></returns>
public static SqlRetryPolicyProvider GetProvider(SqlRetryLogicMethod reliabilityMethod)
{
return(SqlRetryPolicyProviderManager.Instance.GetProvider(reliabilityMethod));
}
/// <summary>
/// Get an authentication provider by method.
/// </summary>
/// <param name="reliabilityMethod">Authentication method.</param>
/// <returns>Authentication provider or null if not found.</returns>
public SqlRetryPolicyProvider GetProvider(SqlRetryLogicMethod reliabilityMethod)
{
SqlRetryPolicyProvider value;
return(_providers.TryGetValue(reliabilityMethod, out value) ? value : null);
}
