public Entrypoint(SlimGetConfiguration config)
{
this.Database = new SlimGetContext(
ConnectionStringProvider.Create(config.Storage.Database));
this.Tokens = TokenService.Create(config.Security);
}
internal OrmLiteConnectionFactory this[string database]
{
get
{
OrmLiteConnectionFactory factory;
if (!ConnFactorys.TryGetValue(database, out factory))
{
var connectStr = ConnectionStringProvider.GetConnectionString(database);
if (string.IsNullOrEmpty(connectStr))
{
connectStr = database;
}
factory = new OrmLiteConnectionFactory(connectStr, MySqlDialect.Provider);
factory.AutoDisposeConnection = true;
factory.OnDispose = m =>
{
if (_connectionDisposehandler != null)
{
_connectionDisposehandler(factory, EventArgs.Empty);
}
};
ConnFactorys.TryAdd(database, factory);
}
return(factory);
}
}
public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
WebHost.CreateDefaultBuilder(args)
.UseStartup <Startup>()
.UseContentRoot(Directory.GetCurrentDirectory())
.ConfigureServices((context, services) =>
{
var connectionStringProvider = new ConnectionStringProvider(context.Configuration, "ApiData");
services.AddSingleton <IConnectionStringProvider>(connectionStringProvider);
services.AddSingleton <INowProvider, NowProvider>();
services.AddSingleton(context.Configuration);
})
.ConfigureLogging((hostingContext, logging) =>
{
logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
logging.AddConsole();
logging.AddDebug();
})
.ConfigureAppConfiguration((builderContext, config) =>
{
var env = builderContext.HostingEnvironment;
config.SetBasePath(env.ContentRootPath)
.AddJsonFile("appsettings.json", false, true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", true, true)
.AddEnvironmentVariables();
if (builderContext.HostingEnvironment.IsDevelopment())
{
config.AddUserSecrets <Startup>();
}
});
/// <summary>
/// Initialization routine
/// </summary>
/// <param name="action">action</param>
/// <returns>initialization task</returns>
private async Task Initialize(Action action)
{
// load the environment configuration file from UtilsInternal
var sr = new FileSettingsReader(ConfigurationManager.AppSettings["ConfigRelativePath"] + Path.DirectorySeparatorChar + environmentName + ".config");
var certThumbprint = sr.ReadValue(SocialPlusCertThumbprint);
var clientID = sr.ReadValue(EmbeddedSocialClientIdSetting);
var storeLocation = StoreLocation.CurrentUser;
var vaultUrl = sr.ReadValue(SocialPlusVaultUrlSetting);
ICertificateHelper cert = new CertificateHelper(certThumbprint, clientID, storeLocation);
IKeyVaultClient client = new AzureKeyVaultClient(cert);
var log = new Log(LogDestination.Console, Log.DefaultCategoryName);
var kv = new KV(log, clientID, vaultUrl, certThumbprint, storeLocation, client);
var kvReader = new KVSettingsReader(sr, kv);
IConnectionStringProvider connectionStringProvider = new ConnectionStringProvider(kvReader);
int queueBatchIntervalMs = int.Parse(sr.ReadValue(ServiceBusBatchIntervalMsSetting));
QueueManager queueManager = new QueueManager(connectionStringProvider, queueBatchIntervalMs);
var sbConnect = await connectionStringProvider.GetServiceBusConnectionString(ServiceBusInstanceType.Default);
// the ListQueues action requires an instance of a ServiceBus object
if (action == Action.ListQueues)
{
this.sb = new ServiceBus(sbConnect);
}
// all the remaining actions operate on an instance of a ServiceBusQueue object
if (action != Action.ListQueues)
{
// ParseArgs() ensures that queueName is valid here
this.sbQueue = await ServiceBusQueue.Create(sbConnect, queueName, queueBatchIntervalMs);
this.selectedQueue = await queueManager.GetQueue((QueueIdentifier)selectedQueueId);
}
}
public ProjectCreationCommandBase(ConnectionStringProvider connectionStringProvider, ICmdHelper cmdHelper)
{
ConnectionStringProvider = connectionStringProvider;
CmdHelper = cmdHelper;
Logger = NullLogger <NewCommand> .Instance;
}
protected virtual SqlConnection GetConnection()
{
SqlConnection connection = null;
if (ConnectionStringProvider == null)
{
return(new SqlConnection("Data Source=(local);Initial Catalog=demo;Integrated Security=True"));
//throw new NullReferenceException(nameof(ConnectionStringProvider));
}
string connectionString = ConnectionStringProvider.Get <T>();
if (String.IsNullOrWhiteSpace(connectionString))
{
throw new NullReferenceException(nameof(connectionString));
}
connection = new SqlConnection(connectionString);
if (connection == null)
{
throw new NullReferenceException(nameof(connection));
}
return(connection);
}
public ProjectCreationCommandBase(ConnectionStringProvider connectionStringProvider, SolutionPackageVersionFinder solutionPackageVersionFinder, ICmdHelper cmdHelper)
{
ConnectionStringProvider = connectionStringProvider;
SolutionPackageVersionFinder = solutionPackageVersionFinder;
CmdHelper = cmdHelper;
Logger = NullLogger <NewCommand> .Instance;
}
public SQLiteDatabase(ConnectionStringProvider connectionStringProvider)
{
SQLiteConnection connection = new SQLiteConnection(connectionStringProvider.GetConnectionString());
_connection = connection ?? throw new InvalidDataBaseOperationException("Cannot construct a database with a null connection. " +
"Check ConnectionStringProvider for problems loading a valid connection string to initialize database.");
_connection.Open(); // TODO Where is the best place to open and close connections?
}
public UploadRContext CreateDbContext(string[] args)
{
var connectionStringProvider = new ConnectionStringProvider(new DesignTimeDatabaseConfigurationProvider());
var builder = new DbContextOptionsBuilder()
.UseNpgsql(connectionStringProvider.ConnectionString);
return(new UploadRContext(builder.Options));
}
public List <Building> GetBuildings(Filter filter)
{
using (var conn = new SqlConnection(ConnectionStringProvider.GetConnectionString()))
{
return(conn.Query <Building>(BuildingQueries.GetBuildingsByFilterQuery(filter))
.ToList());
}
}
public Building GetBuildingById(string buildingId)
{
using (var conn = new SqlConnection(ConnectionStringProvider.GetConnectionString()))
{
var res = conn.QueryFirstOrDefault <Building>(BuildingQueries.GetBuildingByIdQuery(), new { buildingId });
return(res ?? throw new NullReferenceException($"Building with id : {buildingId} not found."));
}
}
public void TestConnectionDoesNotLeak()
{
var applicationName = nameof(TestConnectionDoesNotLeak) + Guid.NewGuid();
var connectionString = new SqlConnectionStringBuilder(ConnectionStringProvider.ConnectionString)
{
ApplicationName = applicationName,
}
.ConnectionString;
using (ConnectionStringProvider.UseConnectionString(connectionString))
using (var engine = this.CreateEngine())
{
var @lock = engine.CreateLock(nameof(TestConnectionDoesNotLeak));
for (var i = 0; i < 30; ++i)
{
using (@lock.Acquire())
{
CountActiveSessions().ShouldEqual(1, this.GetType().Name);
}
// still alive due to pooling
CountActiveSessions().ShouldEqual(1, this.GetType().Name);
}
}
using (var connection = new SqlConnection(connectionString))
{
SqlConnection.ClearPool(connection);
// checking immediately seems flaky; likely clear pool finishing
// doesn't guarantee that SQL will immediately reflect the clear
var maxWaitForPoolsToClear = TimeSpan.FromSeconds(5);
var stopwatch = Stopwatch.StartNew();
do
{
var activeCount = CountActiveSessions();
if (activeCount == 0)
{
return;
}
Thread.Sleep(25);
}while (stopwatch.Elapsed < maxWaitForPoolsToClear);
}
int CountActiveSessions()
{
using (var connection = new SqlConnection(ConnectionStringProvider.ConnectionString))
{
connection.Open();
using (var command = connection.CreateCommand())
{
command.CommandText = $@"SELECT COUNT(*) FROM sys.dm_exec_sessions WHERE program_name = '{applicationName}'";
return((int)command.ExecuteScalar());
}
}
}
}
/// <exception cref="NotSupportedMessageException">Raised when message type is not supported</exception>
public IMessageHandler CreateHandler <T>()
{
var configuration = new AppConfigConfiguration();
var csProvider = new ConnectionStringProvider();
var dbCommands = new DatabaseCommands(csProvider, configuration);
var messagingLogger = new MessagingLogger(dbCommands);
if (typeof(T) == typeof(PriceBandUpdated))
{
var validator = new PriceBandUpdatedValidator(dbCommands);
return(new PriceBandEventHandler(dbCommands, validator, messagingLogger, configuration));
}
if (typeof(T) == typeof(AccountCreated))
{
var validator = new AccountCreatedValidator(dbCommands);
var handler = new AccountCreatedEventHandler(dbCommands, validator, configuration, messagingLogger);
handler.OnProcessed += SendMessage;
return(handler);
}
if (typeof(T) == typeof(AccountCreateFailed))
{
var validator = new AccountCreateFailedValidator(dbCommands);
return(new AccountCreateFailedEventHandler(dbCommands, validator, messagingLogger));
}
if (typeof(T) == typeof(AccountUpdated))
{
var validator = new AccountUpdatedValidator(dbCommands);
return(new AccountUpdatedEventHandler(dbCommands, validator, messagingLogger));
}
if (typeof(T) == typeof(AccountUpdateFailed))
{
var validator = new AccountUpdateFailedValidator(dbCommands);
return(new AccountUpdateFailedEventHandler(dbCommands, validator, messagingLogger));
}
if (typeof(T) == typeof(AccountStatusChanged))
{
var validator = new AccountStatusChangedValidator(dbCommands);
return(new AccountStatusChangedEventHandler(dbCommands, validator, messagingLogger));
}
if (typeof(T) == typeof(AccountStatusChangeFailed))
{
var validator = new AccountStatusChangeFailedValidator(dbCommands);
return(new AccountStatusChangeFailedEventHandler(dbCommands, validator, messagingLogger));
}
if (typeof(T) == typeof(FileUploadCompleted))
{
var validator = new FileUploadEventValidator(dbCommands);
return(new FileUploadCompletedHandler(dbCommands, validator, messagingLogger));
}
throw new NotSupportedMessageException(string.Format("Message type {0} is not supported.", typeof(T).Name));
}
public void GetCachedConnectionString()
{
var provider = new ConnectionStringProvider();
provider.AddConnectionString(typeof(object).ToString(), "a");
var resultA1 = provider.GetConnectionString(typeof(object));
var resultA2 = provider.GetConnectionString(typeof(object));
Assert.AreSame(resultA1, resultA2);
}
// Creates connection to db
protected virtual DbConnection CreateConnection()
{
var databaseName = GetDatabaseName();
var connectionString = ConnectionStringProvider.GetConnectionString(databaseName);
var connection = DatabaseConnectionFactory.Create(connectionString);
return(connection);
}
public List <Building> GetBuildingsByAddress(string address)
{
using (var conn = new SqlConnection(ConnectionStringProvider.GetConnectionString()))
{
var res = conn.Query <Building>(BuildingQueries.GetBuildingByAddressQuery(), new { Address = $"%{address}%" })
.ToList();
return(res ?? throw new NullReferenceException($"Building with address : {address} not found."));
}
}
public NewCommand(TemplateProjectBuilder templateProjectBuilder
, ITemplateInfoProvider templateInfoProvider,
ConnectionStringProvider connectionStringProvider)
: base(connectionStringProvider)
{
TemplateProjectBuilder = templateProjectBuilder;
TemplateInfoProvider = templateInfoProvider;
Logger = NullLogger <NewCommand> .Instance;
}
public virtual LoggerPurgeResponse Purge(LoggerPurgeRequest request)
{
var response = new LoggerPurgeResponse();
if (ConnectionStringProvider != null)
{
try
{
var query = GetPurgeSql();
var constr = ConnectionStringProvider.GetConnectionString();
if (!string.IsNullOrEmpty(constr))
{
using (var con = new SqlConnection(constr))
{
using (var cmd = new SqlCommand(query, con))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddOutput("@Result", SqlDbType.NVarChar, 100);
cmd.Parameters.AddOutput("@Info", SqlDbType.NVarChar);
cmd.Parameters.AddInput("@FromDate", request.FromDate);
cmd.Parameters.AddInput("@ToDate", request.ToDate);
FinalizePurgeCommand(cmd);
con.Open();
cmd.ExecuteNonQuery();
response.SetStatus(cmd.Parameters[0].Value);
response.Info = SafeClrConvert.ToString(cmd.Parameters[1].Value);
}
}
}
else
{
response.Message = "ConnectionStringProvider has no connection string";
response.Info = $"Provider = {ConnectionStringProvider.GetType().Name}";
response.SetStatus("NoConStr");
}
}
catch (Exception e)
{
response.Failed(e);
}
}
else
{
response.Message = "No ConnectionStringProvider is specified";
response.SetStatus("NoConStrProvider");
}
return(response);
}
public NewCommand(TemplateProjectBuilder templateProjectBuilder
, ITemplateInfoProvider templateInfoProvider,
ConnectionStringProvider connectionStringProvider,
SolutionPackageVersionFinder solutionPackageVersionFinder,
ICmdHelper cmdHelper,
IInstallLibsService installLibsService)
: base(connectionStringProvider, solutionPackageVersionFinder, cmdHelper, installLibsService)
{
TemplateProjectBuilder = templateProjectBuilder;
TemplateInfoProvider = templateInfoProvider;
}
public NewCommand(TemplateProjectBuilder templateProjectBuilder
, ITemplateInfoProvider templateInfoProvider,
ConnectionStringProvider connectionStringProvider,
SolutionPackageVersionFinder solutionPackageVersionFinder,
ICmdHelper cmdHelper)
: base(connectionStringProvider, solutionPackageVersionFinder, cmdHelper)
{
TemplateProjectBuilder = templateProjectBuilder;
TemplateInfoProvider = templateInfoProvider;
Logger = NullLogger <NewCommand> .Instance;
}
public void SetUp()
{
var builder = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseSqlServer(ConnectionStringProvider.GetConnectionString());
_context = new ApplicationDbContext(builder.Options);
_sqlParameterFactory = new SqlParameterFactory(new CollectionToDataTableConverter());
_storedProcedureFactory = new StoredProcedureFactory(_sqlParameterFactory);
SqlScriptRunner.SetUpDatabase();
SeedDatabase();
}
public NewCommand(TemplateProjectBuilder templateProjectBuilder
, ITemplateInfoProvider templateInfoProvider,
EfCoreMigrationManager efCoreMigrationManager,
ConnectionStringProvider connectionStringProvider)
{
_efCoreMigrationManager = efCoreMigrationManager;
TemplateProjectBuilder = templateProjectBuilder;
TemplateInfoProvider = templateInfoProvider;
ConnectionStringProvider = connectionStringProvider;
Logger = NullLogger <NewCommand> .Instance;
}
public void StringReturnedMatchesExpected(string time, string expected)
{
// Arrange
var now = TimeKeeper.ToTimeSpan(time);
var csp = new ConnectionStringProvider(DayTimeConnectionString, NightTimeConnectionString, NightTimeStart,
NightTimeEnd, now);
// Act
var value = csp.GetConnectionString();
// Assert
Assert.Equal(value, expected);
}
public void GetPossibleConnectionStrings_ReturnsAllAppSettingsAndConnectionStrings()
{
Environment.SetEnvironmentVariable("TestSetting1", "Test Value 1");
Environment.SetEnvironmentVariable("TestSetting2", "Test Value 2");
var possibleConnections = ConnectionStringProvider.GetPossibleConnectionStrings();
Assert.Equal(possibleConnections["TestSetting1"], "Test Value 1");
Assert.Equal(possibleConnections["TestSetting2"], "Test Value 2");
Assert.Equal(possibleConnections["TestConnection1"], "Test Connection 1");
Assert.Equal(possibleConnections["TestConnection2"], "Test Connection 2");
}
internal Database(string instanceName)
{
this.instanceName = instanceName;
try
{
SetConnectionString(ConnectionStringProvider.GetConnectionString(instanceName));
}
catch
{
throw new DatabaseNotConfiguredException(instanceName);
}
}
public SqlIntegrationTestBase(ITestOutputHelper outputHelper)
{
Output = outputHelper;
DatabaseName = $"IntegrationTests_BaseSchemaRunner_{Guid.NewGuid().ToString().Replace("-", string.Empty)}";
Config = new SqlServerDataStoreConfiguration
{
ConnectionString = Environment.GetEnvironmentVariable("TestSqlConnectionString") ?? $"server=(local);Initial Catalog={DatabaseName};Integrated Security=true",
AllowDatabaseCreation = true,
};
ConnectionStringProvider = Substitute.For <ISqlConnectionStringProvider>();
ConnectionStringProvider.GetSqlConnectionString(Arg.Any <CancellationToken>()).ReturnsForAnyArgs(Config.ConnectionString);
}
public void ReplaceConnectionString()
{
var provider = new ConnectionStringProvider();
provider.AddConnectionString(typeof(object).ToString(), "a");
var resultA = provider.GetConnectionString(typeof(object));
provider.AddConnectionString(typeof(object).ToString(), "b");
var resultB = provider.GetConnectionString(typeof(object));
Assert.AreNotEqual(resultA, resultB);
Assert.AreEqual("b", resultB);
}
internal static BlobBoundParameterModel CreateExtendedBlobModel(FunctionInstanceSnapshot snapshot, FunctionInstanceArgument argument)
{
Debug.Assert(argument != null);
if (argument.Value == null)
{
return(null);
}
string[] components = argument.Value.Split(new char[] { '/' });
if (components.Length != 2)
{
return(null);
}
var blobParam = new BlobBoundParameterModel();
blobParam.IsOutput = argument.IsBlobOutput;
blobParam.ConnectionStringKey = ConnectionStringProvider.GetPrefixedConnectionStringName(argument.AccountName);
CloudStorageAccount account = argument.GetStorageAccount();
if (account == null)
{
blobParam.IsConnectionStringMissing = true;
return(blobParam);
}
CloudBlockBlob blob = account
.CreateCloudBlobClient()
.GetContainerReference(components[0])
.GetBlockBlobReference(components[1]);
Guid?blobWriter = GetBlobWriter(blob);
if (!blobWriter.HasValue)
{
blobParam.IsBlobMissing = true;
}
else
{
blobParam.OwnerId = blobWriter.Value;
if (blobWriter.Value == snapshot.Id)
{
blobParam.IsBlobOwnedByCurrentFunctionInstance = true;
}
}
return(blobParam);
}
public QuoteRepositoryIntegrationTests()
{
cs = new ConnectionStringProvider();
Conn = new SqlConnection(cs.ConnectionString);
var log = new SeriLogFacility <QuoteRepository>(Log.Logger);
Sut = new QuoteRepository(Conn, log);
FluentMapper.EntityMaps.Clear();
FluentMapper.Initialize(cfg => cfg.AddMap(new QuoteSchema()));
Conn.Open();
}
public void Should_get_the_default_with_server()
{
IConfigurationProvider configurationProvider = new FileConfigurationProvider();
IConnectionStringProvider connectionStringProvider = new ConnectionStringProvider(configurationProvider);
string providerName;
string connectionString;
Assert.IsTrue(connectionStringProvider.TryGetConnectionString("default", out connectionString,
out providerName, "remote"));
Assert.AreEqual("Server=remote;Database=test", connectionString);
Assert.AreEqual("easyProvider", providerName);
}
