internal async static Task DeployAsync(
this IDockerContainerManager manager,
ContainerResourceSettings settings,
Stream source,
string databaseConnection,
string databaseName)
{
using (var dacPackage = Microsoft.SqlServer.Dac.DacPackage.Load(source))
{
var deployService = new DacServices(databaseConnection);
var deployScriptRaw = deployService.GenerateDeployScript(dacPackage, databaseName, DacpacOptions.Deploy);
var deployScript = new DeployScript(deployScriptRaw);
deployScript.SetVariable("DefaultDataPath", "/tmp/");
deployScript.SetVariable("DefaultLogPath", "/tmp/");
var sqlScript = deployScript.Generate();
FileInfo scriptFile = CreateSqlFile(sqlScript);
var copyContext = new CopyContext(scriptFile.FullName, $"/tmp/{scriptFile.Name}");
await manager.CopyToContainer(copyContext);
await manager.InvokeCommandAsync(SqlCommand.ExecuteFile(copyContext.Destination, settings));
File.Delete(scriptFile.FullName);
}
}
/// <summary>Initializes a new instance of the <see cref="ContainerInitializer"/> class.</summary>
/// <param name="manager">The manager.</param>
/// <param name="settings">The settings.</param>
public ContainerInitializer(
IDockerContainerManager manager,
ContainerResourceSettings settings)
{
_manager = manager;
_settings = settings;
}
private SqlCommand(
string command,
ContainerResourceSettings settings)
{
_command.Append("/opt/mssql-tools/bin/sqlcmd ");
_command.Append($"-S localhost -U {settings.Username} -P {settings.Password} ");
_command.Append(command);
}
private PSqlCommand(
string command,
ContainerResourceSettings settings)
{
_command.Append("psql ");
_command.Append($"-h localhost -U {settings.Username} ");
_command.Append(command);
}
private CreateDbCommand(
string dbname,
ContainerResourceSettings settings)
{
_command.Append("createdb ");
_command.Append($"-h localhost -U {settings.Username} ");
_command.Append(dbname);
}
/// <summary>
/// Initializes a new instance of the <see cref="DockerContainerManager"/> class.
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="dockerConfiguration"></param>
public DockerContainerManager(ContainerResourceSettings settings,
DockerConfiguration dockerConfiguration)
{
_settings = settings;
_dockerConfiguration = dockerConfiguration;
_client = new DockerClientConfiguration(
LocalDockerUri(),
null,
TimeSpan.FromMinutes(5)
)
.CreateClient(Version.Parse("1.25"));
_authConfig = GetAuthConfig();
}
private CreateDbCommand(
string dbname,
ContainerResourceSettings settings)
{
Parameters = GetContainerExecParameters(
$@"CREATE DATABASE {dbname};
CREATE ROLE developer_{dbname};
GRANT alter,create,delete,drop,index,insert,select,update,trigger,alter routine,
create routine, execute, create temporary tables
ON {dbname}.*
TO '{settings.Username}';",
settings);
}
protected ContainerExecCreateParameters GetContainerExecParameters(
string query,
ContainerResourceSettings settings)
{
return(new ContainerExecCreateParameters
{
AttachStderr = true,
AttachStdin = false,
AttachStdout = true,
Cmd = GetCommand(query, settings),
Detach = false,
Tty = false
});
}
private IList <string> GetCommand(
string query,
ContainerResourceSettings settings)
{
return(new List <string>
{
"mysql",
"-u",
"root",
$"-p{settings.Password}",
"-e",
query
});
}
internal Logger(SourceLevels level, ContainerResourceSettings settings)
{
_settings = settings;
Trace.AutoFlush = true;
_traceSource = new TraceSource("Squadron", level);
_traceSource.Listeners.Clear();
var writerTraceListener = new TextWriterTraceListener(Console.Out)
{
TraceOutputOptions = TraceOptions.None
};
_traceSource.Listeners.Add(writerTraceListener);
}
private void ValidateSettings(ContainerResourceSettings settings)
{
if (string.IsNullOrEmpty(settings.Name))
{
throw new ArgumentException("Can not be null or empty.", nameof(settings.Name));
}
if (string.IsNullOrEmpty(settings.Image))
{
throw new ArgumentException("Can not be null or empty.", nameof(settings.Image));
}
if (settings.InternalPort == 0)
{
throw new ArgumentException("Can not be 0", nameof(settings.InternalPort));
}
}
/// <summary>
/// Initializes the resources
/// </summary>
public async virtual Task InitializeAsync()
{
ResourceOptions = new TOptions();
var builder = ContainerResourceBuilder.New();
ResourceOptions.Configure(builder);
Settings = builder.Build();
SetComposeVariables();
OnSettingsBuilded(Settings);
ValidateSettings(Settings);
DockerConfiguration dockerConfig = Settings.DockerConfigResolver();
Manager = new DockerContainerManager(Settings, dockerConfig);
Initializer = new ContainerInitializer(Manager, Settings);
await Manager.CreateAndStartContainerAsync();
}
/// <summary>
/// Called when after settings are build
/// </summary>
/// <param name="settings">The settings.</param>
protected virtual void OnSettingsBuilded(ContainerResourceSettings settings)
{
}
internal static ContainerExecCreateParameters Execute(string name,
ContainerResourceSettings settings)
=> new CreateDbCommand(name, settings)
.ToContainerExecCreateParameters();
internal static ContainerExecCreateParameters Execute(
string inputFile,
string dbName,
ContainerResourceSettings settings)
=> new SqlCommand($"Use {dbName}; {inputFile}", settings).Parameters;
internal static ContainerExecCreateParameters ExecuteFile(
string inputFile,
string dbName,
ContainerResourceSettings settings)
=> new PSqlCommand($"{dbName} -f {inputFile}", settings)
.ToContainerExecCreateParameters();
private SqlCommand(
string command,
ContainerResourceSettings settings)
{
Parameters = GetContainerExecParameters(command, settings);
}
internal static ContainerExecCreateParameters ExecuteQuery(
string query,
ContainerResourceSettings settings)
=> new SqlCommand($"-q '{query}'", settings)
.ToContainerExecCreateParameters();
