/// <summary>
///
/// </summary>
/// <param name="name">used to display and search</param>
/// <param name="type"></param>
/// <param name="connectionString"></param>
/// <returns></returns>
private static ConnectionProvider RegisterOleDb(string name, ConnectionProviderType type, string connectionString)
{
ConnectionProvider pvd = new OleDbConnectionProvider(name, type, connectionString);
ConnectionProviderManager.Register(pvd);
return(pvd);
}
public MonoConnectionProvider (MonoConnectionProviderFactory factory, ConnectionProviderType type, MSI.MonoTlsProvider tlsProvider, bool enableMonoExtensions)
: base (factory, type, GetFlags (tlsProvider, enableMonoExtensions))
{
this.tlsProvider = tlsProvider;
this.httpProvider = new MonoHttpProvider (this);
this.enableMonoExtensions = enableMonoExtensions;
}
public MonoConnectionProvider(MonoConnectionProviderFactory factory, ConnectionProviderType type, MSI.MonoTlsProvider tlsProvider, bool enableMonoExtensions)
: base(factory, type, GetFlags(tlsProvider, enableMonoExtensions))
{
this.tlsProvider = tlsProvider;
this.httpProvider = new MonoHttpProvider(this);
this.enableMonoExtensions = enableMonoExtensions;
}
public InstrumentationConnectionType (InstrumentationCategory category, ConnectionProviderType clientType, ConnectionProviderType serverType)
{
Category = category;
ClientType = clientType;
ServerType = serverType;
Value = string.Format ("{0}:{1}:{2}", category, clientType, serverType);
}
public ConnectionProvider GetProvider(ConnectionProviderType type)
{
lock (syncRoot) {
Initialize();
return(providers [type]);
}
}
public static bool IsSupported (RenegotiationInstrumentParameters parameters, ConnectionProviderType clientType, ConnectionProviderType serverType)
{
if (parameters.ServerWriteDuringClientRenegotiation && serverType == ConnectionProviderType.OpenSsl)
return false;
return true;
}
public bool IsSupported(ConnectionProviderType type)
{
lock (syncRoot) {
Initialize();
return(providers.ContainsKey(type));
}
}
internal MonoConnectionProvider(ConnectionProviderFactory factory, ConnectionProviderType type, ConnectionProviderFlags flags,
string name, MSI.MonoTlsProvider tlsProvider)
: base(factory, type, GetFlags(flags, tlsProvider))
{
this.name = name;
this.tlsProvider = tlsProvider;
}
public MonoConnectionProvider GetMonoProvider (ConnectionProviderType type)
{
var flags = GetProviderFlags (type);
if ((flags & ConnectionProviderFlags.SupportsMonoExtensions) == 0)
throw new InvalidOperationException ();
return (MonoConnectionProvider)GetProvider (type);
}
protected ConnectionProvider(string name, ConnectionProviderType type, DbConnectionStringBuilder connectionBuilder)
{
this.Name = name;
this.Type = type;
this.ConnectionBuilder = connectionBuilder;
_defaultDatabaseName = new DatabaseName(this, InitialCatalog);
}
public static bool IsSupported(RenegotiationInstrumentParameters parameters, ConnectionProviderType clientType, ConnectionProviderType serverType)
{
if (parameters.ServerWriteDuringClientRenegotiation && serverType == ConnectionProviderType.OpenSsl)
{
return(false);
}
return(true);
}
public DotNetConnectionProvider(ConnectionProviderFactory factory, ConnectionProviderType type, ISslStreamProvider sslStreamProvider)
: base(factory, type, GetFlags())
{
this.sslStreamProvider = sslStreamProvider;
protocols = ProtocolVersions.Tls10;
if ((Flags & ConnectionProviderFlags.SupportsTls12) != 0)
{
protocols |= ProtocolVersions.Tls11 | ProtocolVersions.Tls12;
}
}
public IClient CreateClient(ConnectionProviderType type, IClientParameters parameters)
{
if (type == ConnectionProviderType.DotNet)
{
return(new DotNetClient(GetLocalEndPoint(), parameters));
}
else if (type == ConnectionProviderType.Mono)
{
return(new MonoClient(GetLocalEndPoint(), parameters));
}
throw new NotSupportedException();
}
public ConnectionProviderFlags GetProviderFlags(ConnectionProviderType type)
{
lock (syncRoot) {
Initialize();
ConnectionProvider provider;
if (!providers.TryGetValue(type, out provider))
{
return(ConnectionProviderFlags.None);
}
return(provider.Flags);
}
}
static TestFeature GetConnectionFeature (ConnectionProviderType type, bool server)
{
switch (type) {
case ConnectionProviderType.OpenSsl:
return server ? openSslServerFeature : openSslClientFeature;
case ConnectionProviderType.NewTLS:
return server ? dotNetServerFeature : dotNetClientFeature;
case ConnectionProviderType.MonoWithNewTLS:
return server ? monoServerFeature : monoClientFeature;
default:
return null;
}
}
static TestFeature GetConnectionFeature(ConnectionProviderType type, bool server)
{
switch (type)
{
case ConnectionProviderType.OpenSsl:
return(server ? openSslServerFeature : openSslClientFeature);
case ConnectionProviderType.NewTLS:
return(server ? monoServerFeature : monoClientFeature);
default:
return(null);
}
}
public bool IsSupported(ConnectionProviderType type)
{
if (type == ConnectionProviderType.Mono)
{
return(true);
}
else if (type == ConnectionProviderType.DotNet)
{
return(true);
}
else
{
return(false);
}
}
public IServer CreateServer(ConnectionProviderType type, IServerParameters parameters)
{
if (type == ConnectionProviderType.DotNet)
{
return(new DotNetServer(GetLocalEndPoint(), parameters));
}
else if (type == ConnectionProviderType.Mono)
{
return(new MonoServer(GetLocalEndPoint(), parameters));
}
else
{
throw new NotSupportedException();
}
}
public override bool IsCompatibleWith (ConnectionProviderType type)
{
switch (type) {
case ConnectionProviderType.NewTLS:
case ConnectionProviderType.MonoWithNewTLS:
return IsNewTls;
case ConnectionProviderType.OldTLS:
case ConnectionProviderType.MonoWithOldTLS:
return !IsNewTls;
case ConnectionProviderType.OpenSsl:
return true;
default:
return false;
}
}
public static ConnectionProviderFlags GetConnectionProviderFlags(ConnectionProviderType type)
{
switch (type)
{
case ConnectionProviderType.Legacy:
return(LegacyFlags);
case ConnectionProviderType.AppleTLS:
return(AppleTlsFlags);
case ConnectionProviderType.BoringTLS:
return(BoringTlsFlags);
default:
throw new NotSupportedException(string.Format("Unknown TLS Provider: {0}", type));
}
}
public override bool IsCompatibleWith(ConnectionProviderType type)
{
switch (type)
{
case ConnectionProviderType.NewTLS:
case ConnectionProviderType.MonoWithNewTLS:
return(IsNewTls);
case ConnectionProviderType.OldTLS:
case ConnectionProviderType.MonoWithOldTLS:
return(!IsNewTls);
case ConnectionProviderType.OpenSsl:
return(true);
default:
return(false);
}
}
public override bool IsCompatibleWith (ConnectionProviderType type)
{
return true;
}
protected ConnectionProvider(ConnectionProviderFactory factory, ConnectionProviderType type, ConnectionProviderFlags flags)
{
this.factory = factory;
this.type = type;
this.flags = flags;
}
public static bool IsSupported(GenericConnectionInstrumentParameters parameters, ConnectionProviderType clientType, ConnectionProviderType serverType)
{
return(true);
}
static bool IsEnabled(TestContext ctx, ConnectionProviderType type, bool server)
{
var feature = GetConnectionFeature(type, server);
return(feature != null?ctx.IsEnabled(feature) : false);
}
public bool IsInstrumentationSupported (ConnectionProviderType type)
{
var flags = GetProviderFlags (type);
return (flags & ConnectionProviderFlags.SupportsInstrumentation) != 0;
}
public static bool IsClientEnabled(TestContext ctx, ConnectionProviderType type)
{
return(IsEnabled(ctx, type, false));
}
public static bool IsClientEnabled (TestContext ctx, ConnectionProviderType type)
{
return IsEnabled (ctx, type, false);
}
public MonoConnectionProvider (MonoConnectionProviderFactory factory, ConnectionProviderType type, ConnectionProviderFlags flags)
: base (factory, type, flags)
{
SupportsMonoExtensions = (flags & ConnectionProviderFlags.SupportsMonoExtensions) != 0;
}
public static bool IsServerEnabled (TestContext ctx, ConnectionProviderType type)
{
return IsEnabled (ctx, type, true);
}
public ConnectionProviderTypeAttribute(ConnectionProviderType type)
{
this.type = type;
this.identifier = Type.Name;
}
static bool IsEnabled (TestContext ctx, ConnectionProviderType type, bool server)
{
var feature = GetConnectionFeature (type, server);
return feature != null ? ctx.IsEnabled (feature) : false;
}
public MonoConnectionProvider(ConnectionProviderFactory factory, ConnectionProviderType type, ConnectionProviderFlags flags, string name, MSI.MonoTlsProvider tlsProvider)
: base(factory, type, flags)
{
this.name = name;
this.tlsProvider = tlsProvider;
}
protected ConnectionProviderBase(IClusterManager clusterManager, IConnectionBuilder connectionBuilder, ConnectionProviderType providerType)
{
ClusterManager = clusterManager;
ConnectionBuilder = connectionBuilder;
Type = providerType;
}
public static bool IsSupported (GenericConnectionInstrumentParameters parameters, ConnectionProviderType clientType, ConnectionProviderType serverType)
{
return true;
}
public bool IsMonoSupported (ConnectionProviderType type)
{
var flags = GetProviderFlags (type);
return (flags & ConnectionProviderFlags.SupportsMonoExtensions) != 0;
}
public static bool IsServerEnabled(TestContext ctx, ConnectionProviderType type)
{
return(IsEnabled(ctx, type, true));
}
public bool IsExplicit(ConnectionProviderType type)
{
var flags = GetProviderFlags(type);
return((flags & ConnectionProviderFlags.IsExplicit) != 0);
}
protected ConnectionProviderBase(IClusterManager clusterManager, IConnectionBuilder connectionBuilder, ConnectionProviderType providerType)
{
ClusterManager = clusterManager;
ConnectionBuilder = connectionBuilder;
Type = providerType;
}
public OleDbConnectionProvider(string name, ConnectionProviderType type, string connectionString)
: base(name, type, new OleDbConnectionStringBuilder(connectionString))
{
}
public OleDbConnectionProvider(string name, ConnectionProviderType type, string connectionString)
: base(name, type, connectionString)
{
}
/// <summary>
///
/// </summary>
/// <param name="name">used to display and search</param>
/// <param name="type"></param>
/// <param name="connectionString"></param>
/// <returns></returns>
private static ConnectionProvider RegisterOleDb(string name, ConnectionProviderType type, string connectionString)
{
ConnectionProvider pvd = new OleDbConnectionProvider(name, type, connectionString);
ConnectionProviderManager.Register(pvd);
return pvd;
}
public static ConnectionProviderFlags GetProviderFlags(ConnectionProviderType type)
{
return(Factory.GetProviderFlags(type));
}
public override bool IsCompatibleWith(ConnectionProviderType type)
{
return(true);
}
