private Connection GetConnection(SqlServerServiceInfo info, IConfiguration configuration)
{
var sqlConfig = new SqlServerProviderConnectorOptions(configuration);
var configurer = new SqlServerProviderConfigurer();
return(new Connection(configurer.Configure(info, sqlConfig), "SqlServer", info));
}
private static void DoAdd(IServiceCollection services, SqlServerServiceInfo info, IConfiguration config, ServiceLifetime contextLifetime)
{
var sqlServerConfig = new SqlServerProviderConnectorOptions(config);
var factory = new SqlServerProviderConnectorFactory(info, sqlServerConfig, SqlServerTypeLocator.SqlConnection);
services.Add(new ServiceDescriptor(typeof(IHealthContributor), ctx => new RelationalHealthContributor((IDbConnection)factory.Create(ctx), ctx.GetService <ILogger <RelationalHealthContributor> >()), contextLifetime));
}
public SqlServerDbContextConnectorFactory(SqlServerServiceInfo info, SqlServerProviderConnectorOptions config, Type dbContextType)
: base(info, config, dbContextType)
{
if (dbContextType == null)
{
throw new ArgumentNullException(nameof(dbContextType));
}
}
public void SpecialCharactersInCredentials_AreHandled()
{
var uri = "jdbc:sqlserver://192.168.0.90:1433/databaseName=de5aa3a747c134b3d8780f8cc80be519e";
var r1 = new SqlServerServiceInfo("myId", uri, "!*'();:@&=+$,/?#[] \"%-.<>\\^_`{|}~", "[]!*'();:@&=+$,/?# \"%-.<>\\^_`{|}~");
Assert.Equal("!*'();:@&=+$,/?#[] \"%-.<>\\^_`{|}~", r1.UserName);
Assert.Equal("[]!*'();:@&=+$,/?# \"%-.<>\\^_`{|}~", r1.Password);
}
public static void RegisterSqlServerConnection(IContainer container, IConfigurationRoot config)
{
SqlServerProviderConnectorOptions SqlServerConfig = new SqlServerProviderConnectorOptions(config);
SqlServerServiceInfo info = config.GetSingletonServiceInfo <SqlServerServiceInfo>();
SqlServerProviderConnectorFactory factory = new SqlServerProviderConnectorFactory(info, SqlServerConfig, typeof(SqlConnection));
container.Inject <IBloggingContext>(new BloggingContext((SqlConnection)factory.Create(null)));
}
public void Create_ThrowsIfNoValidConstructorFound()
{
var config = new SqlServerProviderConnectorOptions();
SqlServerServiceInfo si = null;
var dbContextType = typeof(BadSqlServerDbContext);
var ex = Assert.Throws <ConnectorException>(() => new SqlServerDbContextConnectorFactory(si, config, dbContextType).Create(null));
Assert.Contains("BadSqlServerDbContext", ex.Message);
}
public void Constructor_ThrowsIfTypeNull()
{
var config = new SqlServerProviderConnectorOptions();
SqlServerServiceInfo si = null;
Type dbContextType = null;
var ex = Assert.Throws <ArgumentNullException>(() => new SqlServerDbContextConnectorFactory(si, config, dbContextType));
Assert.Contains(nameof(dbContextType), ex.Message);
}
private static void CopyBoundSqlConnection(
IWebConfigWriter webConfig,
SqlServerServiceInfo sqlServiceInfo,
SqlServerProviderConnectorOptions sqlConnectorOptions)
{
SqlServerProviderConnectorFactory sqlConnectorFactory = new SqlServerProviderConnectorFactory(
sqlServiceInfo, sqlConnectorOptions, typeof(SqlConnection));
webConfig.SetConnectionString(sqlServiceInfo.Id, sqlConnectorFactory.CreateConnectionString());
}
private static string GetConnection(IConfiguration config, string serviceName = null)
{
SqlServerServiceInfo info = string.IsNullOrEmpty(serviceName)
? config.GetSingletonServiceInfo <SqlServerServiceInfo>()
: config.GetRequiredServiceInfo <SqlServerServiceInfo>(serviceName);
SqlServerProviderConnectorOptions sqlServerConfig = new SqlServerProviderConnectorOptions(config);
SqlServerProviderConnectorFactory factory = new SqlServerProviderConnectorFactory(info, sqlServerConfig, null);
return(factory.CreateConnectionString());
}
public void Update_With_ServiceInfo_Updates_Config()
{
SqlServerProviderConfigurer configurer = new SqlServerProviderConfigurer();
SqlServerServiceInfo si = new SqlServerServiceInfo("MyId", "jdbc:sqlserver://updatedserver:1433/databaseName=updateddb", "updateduser", "updatedpassword");
configurer.UpdateConfiguration(si, config);
Assert.Equal("updatedserver", config.Server);
Assert.Equal("updateddb", config.Database);
Assert.Equal("updateduser", config.Username);
Assert.Equal("updatedpassword", config.Password);
}
public void Update_With_ServiceInfo_CredsInUrl_Updates_Config()
{
var configurer = new SqlServerProviderConfigurer();
var si = new SqlServerServiceInfo("MyId", "sqlserver://*****:*****@updatedserver:1433;databaseName=updateddb");
configurer.UpdateConfiguration(si, config);
Assert.Equal("updatedserver", config.Server);
Assert.Equal("updateddb", config.Database);
Assert.Equal("updateduser", config.Username);
Assert.Equal("updatedpassword", config.Password);
}
public void UpdateConfiguration(SqlServerServiceInfo si, SqlServerProviderConnectorOptions configuration)
{
if (si == null)
{
return;
}
if (!string.IsNullOrEmpty(si.Uri))
{
configuration.Port = si.Port;
configuration.Server = si.Host;
if (!string.IsNullOrEmpty(si.Path))
{
configuration.Database = si.Path;
}
if (si.Query != null)
{
foreach (var piece in si.Query.Split('&'))
{
var kvp = piece.Split('=');
if (kvp[0].EndsWith("database", StringComparison.InvariantCultureIgnoreCase) || kvp[0].EndsWith("databaseName", StringComparison.InvariantCultureIgnoreCase))
{
configuration.Database = kvp[1];
}
else if (kvp[0].EndsWith("instancename", StringComparison.InvariantCultureIgnoreCase))
{
configuration.InstanceName = kvp[1];
}
else if (kvp[0].StartsWith("hostnameincertificate", StringComparison.InvariantCultureIgnoreCase))
{
// adding this key could result in "System.ArgumentException : Keyword not supported: 'hostnameincertificate'" later
}
else
{
configuration.Options.Add(kvp[0], kvp[1]);
}
}
}
if (configuration.UrlEncodedCredentials)
{
configuration.Username = WebUtility.UrlDecode(si.UserName);
configuration.Password = WebUtility.UrlDecode(si.Password);
}
else
{
configuration.Username = si.UserName;
configuration.Password = si.Password;
}
}
}
public void Constructor_CreatesExpected()
{
var uri = "jdbc:sqlserver://192.168.0.90:1433/databaseName=de5aa3a747c134b3d8780f8cc80be519e";
var r1 = new SqlServerServiceInfo("myId", uri, "Dd6O1BPXUHdrmzbP", "7E1LxXnlH2hhlPVt");
Assert.Equal("myId", r1.Id);
Assert.Equal("sqlserver", r1.Scheme);
Assert.Equal("192.168.0.90", r1.Host);
Assert.Equal(1433, r1.Port);
Assert.Equal("7E1LxXnlH2hhlPVt", r1.Password);
Assert.Equal("Dd6O1BPXUHdrmzbP", r1.UserName);
Assert.Equal("de5aa3a747c134b3d8780f8cc80be519e", r1.Path);
}
private static void DoAdd(IServiceCollection services, SqlServerServiceInfo info, IConfiguration config, ServiceLifetime contextLifetime, bool addSteeltoeHealthChecks)
{
Type sqlServerConnection = SqlServerTypeLocator.SqlConnection;
var sqlServerConfig = new SqlServerProviderConnectorOptions(config);
var factory = new SqlServerProviderConnectorFactory(info, sqlServerConfig, sqlServerConnection);
services.Add(new ServiceDescriptor(typeof(IDbConnection), factory.Create, contextLifetime));
services.Add(new ServiceDescriptor(sqlServerConnection, factory.Create, contextLifetime));
if (!services.Any(s => s.ServiceType == typeof(HealthCheckService)) || addSteeltoeHealthChecks)
{
services.Add(new ServiceDescriptor(typeof(IHealthContributor), ctx => new RelationalHealthContributor((IDbConnection)factory.Create(ctx), ctx.GetService <ILogger <RelationalHealthContributor> >()), ServiceLifetime.Singleton));
}
}
public static void RegisterSqlServerConnection(IContainer container, IConfigurationRoot config)
{
SqlServerProviderConnectorOptions SqlServerConfig = new SqlServerProviderConnectorOptions(config);
SqlServerServiceInfo info1 = config.GetRequiredServiceInfo <SqlServerServiceInfo>("mySqlServerService1"); // config.GetSingletonServiceInfo<SqlServerServiceInfo>();
SqlServerProviderConnectorFactory factory1 = new SqlServerProviderConnectorFactory(info1, SqlServerConfig, typeof(SqlConnection));
container.Inject <IBloggingContext>(new BloggingContext((SqlConnection)factory1.Create(null)));
SqlServerServiceInfo info2 = config.GetRequiredServiceInfo <SqlServerServiceInfo>("mySqlServerService2"); // config.GetSingletonServiceInfo<SqlServerServiceInfo>();
SqlServerProviderConnectorFactory factory2 = new SqlServerProviderConnectorFactory(info2, SqlServerConfig, typeof(SqlConnection));
container.Inject <IVloggingContext>(new VloggingContext((SqlConnection)factory2.Create(null)));
}
public void Constructor_CreatesExpected()
{
string uri = "sqlserver://*****:*****@192.168.0.90:3306/cf_b4f8d2fa_a3ea_4e3a_a0e8_2cd040790355?reconnect=true";
SqlServerServiceInfo r1 = new SqlServerServiceInfo("myId", uri);
Assert.Equal("myId", r1.Id);
Assert.Equal("sqlserver", r1.Scheme);
Assert.Equal("192.168.0.90", r1.Host);
Assert.Equal(3306, r1.Port);
Assert.Equal("7E1LxXnlH2hhlPVt", r1.Password);
Assert.Equal("Dd6O1BPXUHdrmzbP", r1.UserName);
Assert.Equal("cf_b4f8d2fa_a3ea_4e3a_a0e8_2cd040790355", r1.Path);
Assert.Equal("reconnect=true", r1.Query);
}
private static void DoAdd(IServiceCollection services, SqlServerServiceInfo info, IConfiguration config, ServiceLifetime contextLifetime)
{
Type sqlServerConnection = ConnectorHelpers.FindType(sqlServerAssemblies, sqlServerTypeNames);
if (sqlServerConnection == null)
{
throw new ConnectorException("Unable to find System.Data.SqlClient.SqlConnection, are you missing a reference to System.Data.SqlClient?");
}
SqlServerProviderConnectorOptions sqlServerConfig = new SqlServerProviderConnectorOptions(config);
SqlServerProviderConnectorFactory factory = new SqlServerProviderConnectorFactory(info, sqlServerConfig, sqlServerConnection);
services.Add(new ServiceDescriptor(typeof(IDbConnection), factory.Create, contextLifetime));
services.Add(new ServiceDescriptor(sqlServerConnection, factory.Create, contextLifetime));
}
public void Create_ReturnsSqlConnection()
{
SqlServerProviderConnectorOptions config = new SqlServerProviderConnectorOptions()
{
Server = "servername",
Password = "******",
Username = "******",
Database = "database"
};
SqlServerServiceInfo si = new SqlServerServiceInfo("MyId", "jdbc:sqlserver://servername:1433;databaseName=de5aa3a747c134b3d8780f8cc80be519e", "user", "pass");
var factory = new SqlServerProviderConnectorFactory(si, config, typeof(SqlConnection));
var connection = factory.Create(null);
Assert.NotNull(connection);
}
public void Configure_With_ServiceInfo_NamedInstance_Overrides_Config()
{
var configurer = new SqlServerProviderConfigurer();
// override provided by environment
var si = new SqlServerServiceInfo("MyId", "jdbc:sqlserver://servername/databaseName=de5aa3a747c134b3d8780f8cc80be519e;instanceName=someInstance;integratedSecurity=true");
// apply override
var opts = configurer.Configure(si, config);
// resulting options should contain values parsed from environment
Assert.Contains("Data Source=servername\\someInstance", opts);
Assert.Contains("Initial Catalog=de5aa3a747c134b3d8780f8cc80be519e;", opts);
Assert.Contains("integratedSecurity=true;", opts);
}
public void Sql_Is_Connected_Returns_Up_Status()
{
// arrange
Type implementationType = SqlServerTypeLocator.SqlConnection;
var sqlConfig = new SqlServerProviderConnectorOptions();
var sInfo = new SqlServerServiceInfo("MyId", "jdbc:sqlserver://localhost:1433;databaseName=master", "steeltoe", "steeltoe");
var logrFactory = new LoggerFactory();
var connFactory = new SqlServerProviderConnectorFactory(sInfo, sqlConfig, implementationType);
var h = new RelationalHealthContributor((IDbConnection)connFactory.Create(null), logrFactory.CreateLogger <RelationalHealthContributor>());
// act
var status = h.Health();
// assert
Assert.Equal(HealthStatus.UP, status.Status);
}
public void Sql_Is_Connected_Returns_Up_Status()
{
var implementationType = SqlServerTypeLocator.SqlConnection;
var sqlConfig = new SqlServerProviderConnectorOptions()
{
Timeout = 1, ConnectionString = "Server=(localdb)\\MSSQLLocalDB;Integrated Security=true"
};
var sInfo = new SqlServerServiceInfo("MyId", string.Empty);
var logrFactory = new LoggerFactory();
var connFactory = new SqlServerProviderConnectorFactory(sInfo, sqlConfig, implementationType);
var h = new RelationalDbHealthContributor((IDbConnection)connFactory.Create(null), logrFactory.CreateLogger <RelationalDbHealthContributor>());
var status = h.Health();
Assert.Equal(HealthStatus.UP, status.Status);
}
public void Configure_With_ServiceInfo_CredsInUrl_Overrides_Config()
{
var configurer = new SqlServerProviderConfigurer();
// override provided by environment
var si = new SqlServerServiceInfo("MyId", "jdbc:sqlserver://*****:*****@servername:1433/databaseName=de5aa3a747c134b3d8780f8cc80be519e");
// apply override
var opts = configurer.Configure(si, config);
// resulting options should contain values parsed from environment
Assert.Contains("Data Source=servername,1433", opts);
Assert.Contains("Initial Catalog=de5aa3a747c134b3d8780f8cc80be519e;", opts);
Assert.Contains("User Id=Dd6O1BPXUHdrmzbP;", opts);
Assert.Contains("Password=7E1LxXnlH2hhlPVt;", opts);
}
public void UpdateConfiguration(SqlServerServiceInfo si, SqlServerProviderConnectorOptions configuration)
{
if (si == null)
{
return;
}
if (!string.IsNullOrEmpty(si.Uri))
{
configuration.Port = si.Port;
configuration.Server = si.Host;
configuration.Database = si.Path.Replace("databaseName=", string.Empty);
configuration.Username = si.UserName;
configuration.Password = si.Password;
}
}
private static void DoAdd(IServiceCollection services, SqlServerServiceInfo info, IConfiguration config, ServiceLifetime contextLifetime, IHealthChecksBuilder healthChecksBuilder)
{
Type sqlServerConnection = SqlServerTypeLocator.SqlConnection;
var sqlServerConfig = new SqlServerProviderConnectorOptions(config);
var factory = new SqlServerProviderConnectorFactory(info, sqlServerConfig, sqlServerConnection);
services.Add(new ServiceDescriptor(typeof(IDbConnection), factory.Create, contextLifetime));
services.Add(new ServiceDescriptor(sqlServerConnection, factory.Create, contextLifetime));
if (healthChecksBuilder == null)
{
services.Add(new ServiceDescriptor(typeof(IHealthContributor), ctx => new RelationalHealthContributor((IDbConnection)factory.Create(ctx), ctx.GetService <ILogger <RelationalHealthContributor> >()), ServiceLifetime.Singleton));
}
else
{
healthChecksBuilder.AddSqlServer(factory.CreateConnectionString());
}
}
public void Sql_Not_Connected_Returns_Down_Status()
{
var implementationType = SqlServerTypeLocator.SqlConnection;
var sqlConfig = new SqlServerProviderConnectorOptions()
{
Timeout = 1
};
var sInfo = new SqlServerServiceInfo("MyId", "jdbc:sqlserver://localhost:1433/databaseName=invalidDatabaseName", "Dd6O1BPXUHdrmzbP", "7E1LxXnlH2hhlPVt");
var logrFactory = new LoggerFactory();
var connFactory = new SqlServerProviderConnectorFactory(sInfo, sqlConfig, implementationType);
var h = new RelationalDbHealthContributor((IDbConnection)connFactory.Create(null), logrFactory.CreateLogger <RelationalDbHealthContributor>());
var status = h.Health();
Assert.Equal(HealthStatus.DOWN, status.Status);
Assert.Contains(status.Details.Keys, k => k == "error");
}
/// <summary>
/// Add an IHealthContributor to a ServiceCollection for SqlServer
/// </summary>
/// <param name="services">Service collection to add to</param>
/// <param name="config">App configuration</param>
/// <param name="contextLifetime">Lifetime of the service to inject</param>
/// <param name="logFactory">logger factory</param>
/// <returns>IServiceCollection for chaining</returns>
public static IServiceCollection AddSqlServerHealthContributor(this IServiceCollection services, IConfiguration config, ServiceLifetime contextLifetime = ServiceLifetime.Singleton, ILoggerFactory logFactory = null)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
SqlServerServiceInfo info = config.GetSingletonServiceInfo <SqlServerServiceInfo>();
DoAdd(services, info, config, contextLifetime);
return(services);
}
/// <summary>
/// Add SQL Server to a ServiceCollection
/// </summary>
/// <param name="services">Service collection to add to</param>
/// <param name="config">App configuration</param>
/// <param name="contextLifetime">Lifetime of the service to inject</param>
/// <param name="logFactory">logger factory</param>
/// <param name="addSteeltoeHealthChecks">Add Steeltoe health check when community healthchecks exist</param>
/// <returns>IServiceCollection for chaining</returns>
public static IServiceCollection AddSqlServerConnection(this IServiceCollection services, IConfiguration config, ServiceLifetime contextLifetime = ServiceLifetime.Scoped, ILoggerFactory logFactory = null, bool addSteeltoeHealthChecks = false)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
SqlServerServiceInfo info = config.GetSingletonServiceInfo <SqlServerServiceInfo>();
DoAdd(services, info, config, contextLifetime, addSteeltoeHealthChecks);
return(services);
}
public void UpdateConfiguration(SqlServerServiceInfo si, SqlServerProviderConnectorOptions configuration)
{
if (si == null)
{
return;
}
if (!string.IsNullOrEmpty(si.Uri))
{
configuration.Port = si.Port;
configuration.Server = si.Host;
if (!string.IsNullOrEmpty(si.Path))
{
configuration.Database = si.Path;
}
if (si.Query != null)
{
foreach (var kvp in UriExtensions.ParseQuerystring(si.Query))
{
if (kvp.Key.EndsWith("database", StringComparison.InvariantCultureIgnoreCase) || kvp.Key.EndsWith("databaseName", StringComparison.InvariantCultureIgnoreCase))
{
configuration.Database = kvp.Value;
}
else if (kvp.Key.EndsWith("instancename", StringComparison.InvariantCultureIgnoreCase))
{
configuration.InstanceName = kvp.Value;
}
else if (kvp.Key.StartsWith("hostnameincertificate", StringComparison.InvariantCultureIgnoreCase))
{
// adding this key could result in "System.ArgumentException : Keyword not supported: 'hostnameincertificate'" later
}
else
{
configuration.Options.Add(kvp.Key, kvp.Value);
}
}
}
configuration.Username = si.UserName;
configuration.Password = si.Password;
}
}
public void Create_ReturnsDbContext()
{
var config = new SqlServerProviderConnectorOptions()
{
Server = "localhost",
Port = 1433,
Password = "******",
Username = "******",
Database = "database"
};
var si = new SqlServerServiceInfo("MyId", "SqlServer://192.168.0.90:1433/cf_b4f8d2fa_a3ea_4e3a_a0e8_2cd040790355", "Dd6O1BPXUHdrmzbP", "7E1LxXnlH2hhlPVt");
var factory = new SqlServerDbContextConnectorFactory(si, config, typeof(GoodSqlServerDbContext));
var context = factory.Create(null);
Assert.NotNull(context);
var gcontext = context as GoodSqlServerDbContext;
Assert.NotNull(gcontext);
}
/// <summary>
/// Add your SqlServer-based DbContext to the ContainerBuilder
/// </summary>
/// <typeparam name="TContext">Your DbContext</typeparam>
/// <param name="container">Autofac <see cref="ContainerBuilder" /></param>
/// <param name="config">Your app config</param>
/// <param name="serviceName">Name of service instance</param>
/// <returns><see cref="IRegistrationBuilder{TLimit, TActivatorData, TRegistrationStyle}"/></returns>
public static IRegistrationBuilder <object, SimpleActivatorData, SingleRegistrationStyle> RegisterDbContext <TContext>(this ContainerBuilder container, IConfiguration config, string serviceName = null)
{
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
SqlServerServiceInfo info = serviceName == null
? config.GetSingletonServiceInfo <SqlServerServiceInfo>()
: config.GetRequiredServiceInfo <SqlServerServiceInfo>(serviceName);
var sqlServerConfig = new SqlServerProviderConnectorOptions(config);
var factory = new SqlServerProviderConnectorFactory(info, sqlServerConfig, typeof(TContext));
return(container.Register(c => factory.Create(null)).As <TContext>());
}
