private static void setImageParameters(Docker.DotNet.Models.CreateContainerParameters createContainerParams, IReadOnlyCollection <string> containerParams, ILogger logger)
{
foreach (var param in containerParams)
{
var eqIdx = param.IndexOf('=');
if (eqIdx == -1)
{
logger.LogWarning($"Container param {param} invalid");
continue;
}
try
{
var key = param.Substring(0, eqIdx);
var value = param.Substring(eqIdx + 1);
if (trySetDynamicPropertyOn(createContainerParams, key, value))
{
continue;
}
if (trySetDynamicPropertyOn(createContainerParams.HostConfig, key, value))
{
continue;
}
logger.LogWarning($"Unknown container parameter {key}");
}
catch
{
logger.LogWarning($"Cannot set container parameter {param}");
}
}
}
public static async Task <DockerContainer> CreateNewContainer(ContainerConfig config, Docker.DotNet.DockerClient docker, ILogger logger, CancellationToken cancellationToken, Action <Docker.DotNet.Models.CreateContainerParameters>?configure = null)
{
try
{
var createContainerParams = new Docker.DotNet.Models.CreateContainerParameters()
{
Image = config.ImageName,
Labels = DockerObjectBase.LabelsForCreation,
HostConfig = new Docker.DotNet.Models.HostConfig()
{
Mounts = new List <Docker.DotNet.Models.Mount>()
{
}
},
Env = config.EnvVariables.ToList()
};
if (config.CreateParams != null && config.CreateParams.Any())
{
setImageParameters(createContainerParams, config.CreateParams, logger);
}
configure?.Invoke(createContainerParams);
var createContainerResponse = await docker.Containers.CreateContainerAsync(createContainerParams, cancellationToken);
if (string.IsNullOrEmpty(createContainerResponse.ID))
{
throw new Exception("Container create failed with unknown error");
}
logger.LogTrace($"Container created with ID {createContainerResponse.ID}");
return(new DockerContainer(createContainerResponse.ID, logger, docker));
}
catch (Docker.DotNet.DockerImageNotFoundException)
{
throw new Exception($"Image {config.ImageName} not found.");
}
catch (Docker.DotNet.DockerApiException ex)
{
throw new Exception($"Container create failed with error: {ex.Message}", ex);
}
}
protected void configureMount(Docker.DotNet.Models.CreateContainerParameters createContainerParams, string solutionFolderToMount)
{
createContainerParams.HostConfig.Mounts.Add(new Docker.DotNet.Models.Mount()
{
Type = "bind",
Source = solutionFolderToMount,
Target = task.SubmissionDirectoryInContainer,
ReadOnly = false
});
if (task.HasArtifactDirectory)
{
System.IO.Directory.CreateDirectory(task.ArtifactPathInMachine); // must exist for the mount
createContainerParams.HostConfig.Mounts.Add(new Docker.DotNet.Models.Mount()
{
Type = "bind",
Source = task.ArtifactPathInMachine,
Target = task.ArtifactPathInContainer,
ReadOnly = false
});
}
}
public async Task <string> RunContainer(Docker.DotNet.Models.AuthConfig authConfig, string dockerRepository, string imageTag, IList <string> command, IDictionary <string, string> environment, string hostWorkingDirectory)
{
List <string> env = environment.Select(kv => kv.Key + "=" + kv.Value).ToList();
env.Add("LC_ALL=en_EN.utf8");
env.Add("TERM=dumb");
var console = new DockerConsole(this, dockerRepository);
SimulatorConsole.Instance.AddTab(console);
SimulatorConsole.Instance.ChangeTab(console);
var dockerImage = $"{dockerRepository}:{imageTag}";
var createConfig = new Docker.DotNet.Models.ImagesCreateParameters
{
FromImage = dockerRepository,
Tag = imageTag
};
Debug.Log($"Pulling image {dockerRepository}:{imageTag}");
await dockerClient.Images.CreateImageAsync(createConfig, authConfig, console);
var createParams = new Docker.DotNet.Models.CreateContainerParameters()
{
Hostname = "",
Domainname = "",
Image = dockerImage,
Cmd = command,
User = "******",
AttachStdout = true,
AttachStderr = true,
AttachStdin = true,
Tty = true,
OpenStdin = true,
StdinOnce = true,
HostConfig = new Docker.DotNet.Models.HostConfig
{
Binds = new[] { hostWorkingDirectory + ":/scenarios" },
NetworkMode = "host",
RestartPolicy = new Docker.DotNet.Models.RestartPolicy {
Name = Docker.DotNet.Models.RestartPolicyKind.No, MaximumRetryCount = 0
},
AutoRemove = false,
Privileged = false,
PublishAllPorts = false,
ReadonlyRootfs = false,
},
Env = env,
WorkingDir = "/scenarios",
};
Debug.Log("Creating container");
var response = await dockerClient.Containers.CreateContainerAsync(createParams);
console.CompleteProgress();
Debug.Log("created container " + response.ID + " " + string.Join(", ", response.Warnings));
var container = await dockerClient.Containers.InspectContainerAsync(response.ID);
Debug.Log("Attaching to container");
var containerAttachParameters = new Docker.DotNet.Models.ContainerAttachParameters
{
Stream = true,
Stderr = true,
Stdin = true,
Stdout = true,
};
var containerStream = await dockerClient.Containers.AttachContainerAsync(container.ID, true, containerAttachParameters);
console.WriteLine($"Image: {dockerImage}");
console.WriteLine($"Created container: {container.ID} {container.Name}");
console.WriteLine($"working directory: {hostWorkingDirectory}");
console.WriteLine($"environment: {string.Join("; ", env)}");
console.WriteLine("---------------------------------");
console.ReadStream(containerStream);
var startParams = new Docker.DotNet.Models.ContainerStartParameters();
containers.Add(
container.ID,
new ContainerData
{
imageName = dockerImage,
console = console,
});
Debug.Log("Start container");
var result = await dockerClient.Containers.StartContainerAsync(container.ID, startParams);
if (!result)
{
throw new Exception("Docker launch failed");
}
return(container.ID);
}
/// <summary>
/// Performs the playback of actions in this module.
/// </summary>
/// <remarks>You should not call this method directly, instead pass the module
/// instance to the <see cref="TestModuleRunner.Run(ITestModule)"/> method
/// that will in turn invoke this method.</remarks>
void ITestModule.Run()
{
// docker run --name wp1 -p 5556:80 --link mysql:mysql
// -e WORDPRESS_DB_PASSWORD=pwd -e WORDPRESS_DB_NAME=wp1 -d wordpress
ServicePointManager.ServerCertificateValidationCallback += (o, c, ch, er) => true;
DockerClient client = null;
if (certFile.Length > 0)
{
var credentials = new CertificateCredentials(new X509Certificate2(certFile));
client = new DockerClientConfiguration(new Uri(dockerURL), credentials).CreateClient();
}
else
{
client = new DockerClientConfiguration(new Uri(dockerURL)).CreateClient();
}
Random r = new Random();
int portNr = r.Next(1500, 8000);
TestSuite.CurrentTestContainer.Parameters["URL"] = TestSuite.CurrentTestContainer.Parameters["URL"] + ":" + portNr.ToString();
//Report.Info(portNr.ToString());
//Report.Info(TestSuite.CurrentTestContainer.Parameters["URL"]);
Docker.DotNet.Models.HostConfig hostConf = new Docker.DotNet.Models.HostConfig();
hostConf.Links = new List <string>();
hostConf.Links.Add("mysql");
var portBindings = new Dictionary <string, IList <Docker.DotNet.Models.PortBinding> > {
{
80.ToString(), new List <Docker.DotNet.Models.PortBinding> {
new Docker.DotNet.Models.PortBinding {
HostPort = portNr.ToString(),
HostIP = "0.0.0.0"
}
}
}
};
var exposedPorts = new Dictionary <string, object>()
{
{ 80.ToString(), new { HostPort = portNr.ToString() } }
};
hostConf.PortBindings = portBindings;
Docker.DotNet.Models.CreateContainerParameters createContainerParams = new Docker.DotNet.Models.CreateContainerParameters();
createContainerParams.HostConfig = hostConf;
createContainerParams.Image = "a8f5a76ca5cd";
createContainerParams.Env = new List <string>();
createContainerParams.Env.Add("WORDPRESS_DB_PASSWORD=pwd");
createContainerParams.Env.Add(String.Format("WORDPRESS_DB_NAME=wp{0}", portNr));
createContainerParams.ExposedPorts = exposedPorts;
var createTask = client.Containers.CreateContainerAsync(createContainerParams);
createTask.Wait();
var container = createTask.Result;
TestSuite.CurrentTestContainer.Parameters["containerID"] = container.ID;
var incpectTask = client.Containers.InspectContainerAsync(container.ID);
incpectTask.Wait();
var inspect = incpectTask.Result;
var startParams = new Docker.DotNet.Models.ContainerStartParameters();
var startTast = client.Containers.StartContainerAsync(container.ID, startParams);
startTast.Wait();
}
