public PullViewModel(DockerService docker)
{
_docker = docker;
Progress = new ProgressViewModel();
_name = "nginx:latest";
IsDownloading = false;
}
public DockerImageListViewModel(AppBrowserViewModel appBrowserViewModel, DockerService service)
{
this.appBrowserViewModel = appBrowserViewModel;
this.service = service;
ModuleName = "Images";
imagesMapper = new ObservableCollectionMapper <DockerImage, DockerImageViewModel>(
image => new DockerImageViewModel(service, image),
viewModel => viewModel.Image,
(image, viewModel) => viewModel.Update(),
(viewModel1, viewModel2) =>
{
int r = string.CompareOrdinal(viewModel1.RepoTagsAsText, viewModel2.RepoTagsAsText);
if (r == 0)
{
r = string.CompareOrdinal(viewModel1.RepoDigestsAsText, viewModel2.RepoDigestsAsText);
}
if (r == 0)
{
r = string.CompareOrdinal(viewModel1.Id, viewModel2.Id);
}
return(r);
}
);
RefreshCommand = new BasicCommand(() => service.Connected, o => service.Refresh());
DeleteImagesCommand = new BasicCommand(() => service.Connected && SelectedImages.Count > 0, o => DeleteImages());
SelectedImages.CollectionChanged += (sender, args) => { DeleteImagesCommand.UpdateState(); };
service.StageChanged += () => appBrowserViewModel.ViewContext.Invoke(Update);
Update();
}
public ImageViewModel(DockerService docker, ImagesListResponse image)
{
_docker = docker;
Name = image.RepoTags?.ElementAt(0) ?? "---";
ID = image.ID;
ShortID = ID.Substring(7, 12);
IsRoot = image.ParentID == string.Empty;
Size = image.Size;
DisplaySize = $"{((float)image.Size) / 1024 / 1024:F1}MB";
Tags = image.RepoTags !;
_raw = image;
ConfirmDeleteImage = new Interaction <MessageBoxStandardParams, ButtonResult>();
NewContainer = new NewContainerViewModel(docker, this);
Task.Run(async() =>
{
var d = await docker.Client.Images.InspectImageAsync(ID);
var exposedPorts = d.Config.ExposedPorts;
if (exposedPorts == null)
{
return;
}
var x = exposedPorts.Keys.ToArray();
ExposedPorts = x;
});
}
public ContainerViewModel(DockerService docker, ContainerListResponse container)
{
_docker = docker;
ID = container.ID;
Name = container.Names[0];
ImageName = container.Image;
void UpdateContainerDetails() => Task.Run(async() =>
{
var d = await docker.Client.Containers.InspectContainerAsync(ID);
IsStarted = d.State.Running;
IsRemovable = !IsStarted || !d.HostConfig.AutoRemove;
string FormatHostPort(PortBinding b) =>
$"{b.HostIP}:{b.HostPort}".Replace("0.0.0.0", docker.Name);
PublicPorts = d.NetworkSettings.Ports.Values
.SelectMany(bs => bs.Select(FormatHostPort))
.ToArray();
});
UpdateContainerDetails();
docker.Events
.Where(e => e.Type == DockerEventType.Container && e.Subject == ID)
.Subscribe(e => UpdateContainerDetails());
}
public async Task<IActionResult> Run(string serviceName, [FromBody]RunOptions options)
{
var website = await this.client.GetWebsite(serviceName);
if(website == null)
return this.NotFound();
if(website.DockerUrl != null)
{
return this.BadRequest("This website is already a container. Do a start instead. Url: " +website.DockerUrl);
}
var result = await DockerService.RunDockerImage(website.Name, options.port, "./");
if(result.Any(p => p.IsError && !String.IsNullOrEmpty(p.Message)))
{
return this.BadRequest("Cannot create container for running.");
}
var containerId = await DockerService.GetContainerId(website.Name);
var ports = await DockerService.GetContainerPortsExposed(containerId);
var containerPort = ports.Select(p => p.Split(" -> ")[1]).FirstOrDefault();
if(containerPort == null)
return this.BadRequest("Could not get port manually.");
website.DockerUrl = new Uri($"{bindingAddress}:{containerPort}");
await this.client.UpdateWebsite(website.Name, website);
return this.Ok("Ok");
}
public override void Run()
{
Console.WriteInfoLine("Removing a database...");
base.Run();
if (!Console.Confirm())
{
return;
}
using (var client = new DockerService())
{
var container = client.GetContainer(true, $"^.*{ContainerKey}-{User}-{Name}$");
if (container == null)
{
Console.WriteErrorLine($"A {ContainerKey} database named {Name} does not exist for user {User}");
return;
}
if (container.State == "running")
{
client.StopContainer(container.ID);
}
client.RemoveContainer(container.ID);
}
Console.WriteSuccessLine("The database was successfully removed.");
}
public BuildDockerCommand(RabbitMessage receiver, DockerService service, DiscoveryServiceClient client) :
base(receiver)
{
this.receiver = receiver;
this.service = service;
this.client = client;
}
public MainWindowViewModel()
{
var docker = new DockerService();
Pull = new PullViewModel(docker);
Images = new ImagesViewModel(docker);
Containers = new ContainersViewModel(docker);
}
public DockerImageViewModel(DockerService service, DockerImage image)
{
Service = service;
Image = image;
Id = image.Id;
Update();
}
public ContainersViewModel(DockerService docker)
{
docker.Containers
.Connect()
.Select(x => new ContainerViewModel(docker, x))
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(out _containers)
.Subscribe();
}
private static async Task <bool> runCompetetionInsideReusableContainer(Gene gene, string mapPath, DirectoryInfo rootDirectory, CancellationToken cancellationToken = default)
{
var hasFinished = true;
//await initializeCompeteionDirectory(gene, 7099, mapPath, rootDirectory, overWriteFiles: true, cancellationToken: cancellationToken);
var containerInfo = await ContainerRepository.GetAFreeContainer(cancellationToken);
try
{
//foreach (var file in rootDirectory.GetFiles())
//{
// file.CopyTo(Path.Combine(containerInfo.FilesDirectory.FullName, file.Name), true);
//}
await initializeCompeteionDirectory(gene, 7099, mapPath, containerInfo.FilesDirectory, overWriteFiles : true, cancellationToken : cancellationToken);
await DockerService.StartContainer(containerInfo.Id, cancellationToken);
var startTime = DateTime.Now;
while (await DockerService.IsContainerRunningAsync(containerInfo.Id, cancellationToken))
{
if ((DateTime.Now - startTime) > _maximumAllowedRunTime)
{
//Console.WriteLine($"gene {geneId} didn't finish");
hasFinished = false;
break;
}
await Task.Delay(1000, cancellationToken);
}
containerInfo.FilesDirectory.CopyContentsTo(rootDirectory);
if (hasFinished)
{
var defenderClientOutputPath = ClientManager.GetClientOutputPath(rootDirectory, ClientMode.defend);
var attackerClientOutputPath = ClientManager.GetClientOutputPath(rootDirectory, ClientMode.attack);
hasFinished = File.Exists(defenderClientOutputPath) && File.Exists(attackerClientOutputPath);
}
var containerInfoPath = Path.Combine(rootDirectory.FullName, "container.info");
await File.AppendAllLinesAsync(containerInfoPath, await DockerService.GetContainerInfo(containerInfo.Id, showAll: true, cancellationToken: cancellationToken), cancellationToken);
var containerInspect = Path.Combine(rootDirectory.FullName, "container.inspect.json");
await File.WriteAllTextAsync(containerInspect, await DockerService.GetContainerInspect(containerInfo.Id, cancellationToken: cancellationToken), cancellationToken);
var containerLogPath = Path.Combine(rootDirectory.FullName, "container.log");
await File.WriteAllTextAsync(containerLogPath, await DockerService.ContainerLogAsync(containerInfo.Id, cancellationToken), cancellationToken);
return(hasFinished);
}
finally
{
containerInfo.Release();
}
}
public DockerContainerViewModel(DockerService service, DockerContainer container)
{
Service = service;
Container = container;
Id = container.Id;
Update();
EnableLogsCommand = new BasicCommand(() => Service.Connected, o => service.EnableLogs(Id));
}
public async Task<IActionResult> Remove(string serviceName, [FromBody]CommandOptions options)
{
var website = await this.client.GetWebsite(serviceName);
if(website == null)
return this.NotFound();
var result = await DockerService.ExecuteCommand(website.Name, options.command);
var message = string.Join("\n", result.Select(p => (p.IsError ? "[ERROR]: " : "[Message]: ") + p.Message));
return this.Ok(message);
}
public async Task<IActionResult> Copy(string serviceName, [FromBody] CopyOptions options)
{
var website = await this.client.GetWebsite(serviceName);
if(website == null)
return this.NotFound();
var result = await DockerService.CopyFileToContainer(website.Name, options.hostPath, options.containerPath);
var message = string.Join("\n", result.Select(p => (p.IsError ? "[ERROR]: " : "[Message]: ") + p.Message));
return this.Ok(message);
}
public async Task<IActionResult> Start(string serviceName)
{
var website = await this.client.GetWebsite(serviceName);
if(website == null)
return this.NotFound();
var result = await DockerService.StartDockerImage(website.Name, null, website.Path);
var message = string.Join("\n", result.Select(p => (p.IsError ? "[ERROR]: " : "[Message]: ") + p.Message));
return this.Ok(message);
}
public NewContainerViewModel(DockerService docker, ImageViewModel image)
{
_docker = docker;
_image = image;
_name = string.Empty;
IsAutoRemove = true;
_portMapping = image
.WhenPropertyChanged(i => i.ExposedPorts)
.Select(x => x.Value?.Select(e => new PortMappingViewModel(e))?.ToArray())
.ToProperty(this, x => x.PortMapping) !;
}
public override void Run()
{
Console.WriteInfoLine("Listing user's database...");
base.Run();
using (var client = new DockerService())
{
var containers = client.GetContainers(true, $"^.*-{User}-.*$");
foreach (var container in containers)
{
Console.WriteInfoLine($"{container.Names.First()} ({container.State} {container.Status})");
}
Console.WriteSuccessLine("Databases was successfully listed.");
}
}
private static async Task <bool> runCompetitionInsideContainer(Gene gene, string mapPath, DirectoryInfo rootDirectory, CancellationToken cancellationToken = default)
{
await initializeCompeteionDirectory(gene, 7099, mapPath, rootDirectory, cancellationToken : cancellationToken);
var containerId = await DockerService.RunArenaAsync(Program.DockerImageName, rootDirectory.FullName, cancellationToken);
var startTime = DateTime.Now;
var hasFinished = true;
while (await DockerService.IsContainerRunningAsync(containerId, cancellationToken))
{
if ((DateTime.Now - startTime) > _maximumAllowedRunTime)
{
//Console.WriteLine($"gene {geneId} didn't finish");
hasFinished = false;
break;
}
await Task.Delay(1000, cancellationToken);
}
if (hasFinished)
{
var defenderClientOutputPath = ClientManager.GetClientOutputPath(rootDirectory, ClientMode.defend);
var attackerClientOutputPath = ClientManager.GetClientOutputPath(rootDirectory, ClientMode.attack);
hasFinished = File.Exists(defenderClientOutputPath) && File.Exists(attackerClientOutputPath);
}
var containerInfoPath = Path.Combine(rootDirectory.FullName, "container.info");
await File.AppendAllLinesAsync(containerInfoPath,
await DockerService.GetContainerInfo(containerId, showAll: true, cancellationToken: cancellationToken),
cancellationToken);
var containerInspect = Path.Combine(rootDirectory.FullName, "container.inspect.json");
await File.WriteAllTextAsync(containerInspect,
await DockerService.GetContainerInspect(containerId, cancellationToken: cancellationToken),
cancellationToken);
var containerLogPath = Path.Combine(rootDirectory.FullName, "container.log");
await File.WriteAllTextAsync(containerLogPath,
await DockerService.ContainerLogAsync(containerId, cancellationToken),
cancellationToken);
await DockerService.StopAndRemoveContainerAsync(containerId, cancellationToken);
return(hasFinished);
}
public override void Run()
{
Console.WriteInfoLine("Creating a new database...");
base.Run();
new IdentityService().CheckUserExists(User);
using (var client = new DockerService())
{
var container = client.GetContainer(true, $"^.*{ContainerKey}-{User}-{Name}$");
if (container != null)
{
Console.WriteErrorLine($"A {ContainerKey} database named {Name} already exists for the user {User}. You cannot ask for a new one.");
return;
}
client.CreateContainer("httpd", $"{ContainerKey}-{User}-{Name}");
Console.WriteSuccessLine("The database was successfully created.");
}
}
public DockerServiceViewModel(AppBrowserViewModel appBrowserViewModel, DockerService service)
{
this.appBrowserViewModel = appBrowserViewModel;
this.service = service;
ModuleName = service.Name;
imageList = new DockerImageListViewModel(appBrowserViewModel, service);
containerList = new DockerContainerListViewModel(appBrowserViewModel, service);
ConnectCommand = new BasicCommand(() => !service.Connected, o => service.Connect());
DisconnectCommand = new BasicCommand(() => service.Connected, o => service.Disconnect());
RefreshCommand = new BasicCommand(() => service.Connected, o => service.Refresh());
service.StageChanged += () => appBrowserViewModel.ViewContext.Invoke(Update);
Update();
}
public ImagesViewModel(DockerService docker)
{
docker.Images
.Connect()
.Select(x => new ImageViewModel(docker, x))
.Sort(Comparer <ImageViewModel> .Create((x, y) => string.Compare(x.Name, y.Name, StringComparison.Ordinal)))
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(out _list)
.Subscribe(_ =>
{
AsTree = Tree <ImageViewModel> .Create <ImageNode>(
AsList,
image => image.IsRoot,
(child, parent, _) => child.IsChildOf(parent),
(p, c) => new ImageNode(p, c)
);
});
}
internal async Task <Dictionary <string, Project> > GetAllDockerContainers(string egwFolder)
{
var allServices = new Dictionary <string, Project>();
var dockerService = new DockerService();
foreach (var project in Info.Projects)
{
if (project.Directory == null)
{
continue;
}
var services = await dockerService.GetDockerServices(Path.Combine(egwFolder, project.Directory, "docker", "egw-tests"));
foreach (var service in services.Where(s => !string.IsNullOrWhiteSpace(s)))
{
allServices.Add(service, project);
}
}
return(allServices);
}
internal async Task <List <string> > GetRunningDockerContainers(string egwFolder)
{
var dockerService = new DockerService();
var dgDir = Info.Projects.First(p => p.Code == "DG").Directory;
if (dgDir == null)
{
return(new List <string>());
}
var services = await dockerService.GetRunningDockerContainers(Path.Combine(egwFolder, dgDir, "docker", "egw-tests"));
services = services.Where(s => !string.IsNullOrWhiteSpace(s)).ToList();
var dg = Info.Projects.First(p => p.Code == "DG");
var kafkaServices = await dockerService.GetRunningDockerContainers(Path.Combine(egwFolder, dg.Directory, "docker", "kafka"));
foreach (var service in kafkaServices.Where(s => !string.IsNullOrWhiteSpace(s)))
{
services.Add(service);
}
return(services);
}
public DockerContainerListViewModel(AppBrowserViewModel appBrowserViewModel, DockerService service)
{
this.appBrowserViewModel = appBrowserViewModel;
this.service = service;
ModuleName = "Containers";
containersMapper = new ObservableCollectionMapper <DockerContainer, DockerContainerViewModel>(
container => new DockerContainerViewModel(service, container),
viewModel => viewModel.Container,
(container, viewModel) => viewModel.Update(),
(viewModel1, viewModel2) =>
{
int r = string.CompareOrdinal(viewModel1.Image, viewModel2.Image);
if (r == 0)
{
r = string.CompareOrdinal(viewModel1.Id, viewModel2.Id);
}
return(r);
}
);
RefreshCommand = new BasicCommand(() => service.Connected, o => service.Refresh());
StartContainersCommand = new BasicCommand(() => service.Connected && SelectedContainers.Count > 0, o => StartContainers());
StopContainersCommand = new BasicCommand(() => service.Connected && SelectedContainers.Count > 0, o => StopContainers());
SelectedContainers.CollectionChanged += (sender, args) =>
{
StartContainersCommand.UpdateState();
StopContainersCommand.UpdateState();
};
service.StageChanged += () => appBrowserViewModel.ViewContext.Invoke(Update);
service.LogChanged += UpdateLog;
Update();
timer = new Timer(TimerCallback, null, 0, 500);
}
public void AddDockerService()
{
DockerSettingsViewModel settings = new DockerSettingsViewModel();
settings.ServiceName = "Docker";
settings.MachineName = "default";
if (!appBrowserViewModel.ViewContext.ShowDialog(settings))
{
return;
}
DockerService service = new DockerService();
service.Name = settings.ServiceName;
service.MachineName = settings.MachineName;
environment.AddService(service);
IServiceViewModel serviceViewModel = Services.FirstOrDefault(s => s.Service == service);
appBrowserViewModel.MainForm.ModulesTree.SelectedModule = serviceViewModel;
}
public override void Run()
{
Console.WriteInfoLine("Stopping a database...");
base.Run();
using (var client = new DockerService())
{
var container = client.GetContainer(true, $"^.*{ContainerKey}-{User}-{Name}$");
if (container == null)
{
Console.WriteErrorLine($"A {ContainerKey} database named {Name} does not exist for user {User}");
return;
}
if (container.State != "running")
{
Console.WriteErrorLine($"A {ContainerKey} database named {Name} exists for user {User}, but its status is not equal to running");
return;
}
client.StopContainer(container.ID);
Console.WriteSuccessLine("The database was successfully stopped.");
}
}
public static async Task RunCompetitions(string mapPath, CompetetionMode competetionMode, CancellationToken cancellationToken = default)
{
switch (competetionMode)
{
case CompetetionMode.NoContainer:
break;
case CompetetionMode.ContainerPerCompetetion:
await DockerService.BuildImageAsync(Directory.GetCurrentDirectory(), Program.DockerImageName, cancellationToken);
await DockerService.StopAndRemoveAllContainersAsync(cancellationToken);
break;
case CompetetionMode.ReusableContainer:
await DockerService.BuildImageAsync(Directory.GetCurrentDirectory(), Program.DockerImageName, cancellationToken);
await DockerService.StopAndRemoveAllContainersAsync(cancellationToken);
await ContainerRepository.InitalizeContainers(_geneProcessLimit, Program.DockerImageName, cancellationToken);
break;
}
_arenaStartTime = DateTime.Now;
Console.WriteLine("welcome to Colosseum. enjoy the show :)");
List <Gene> lastGeneration = null;
var lastGenerationFile = new FileInfo("generationInfo.json");
if (lastGenerationFile.Exists)
{
Console.WriteLine($"loading last generation from {lastGenerationFile.FullName}");
try
{
var content = await File.ReadAllTextAsync(lastGenerationFile.FullName, cancellationToken);
lastGeneration = JsonConvert.DeserializeObject <List <Gene> >(content);
}
catch (Exception ex)
{
Console.WriteLine($"loading last generation failed. error:{Environment.NewLine}{ex}");
}
}
var generationNumber = 1;
var arenaDir = new DirectoryInfo("arena");
arenaDir.Create();
var currentRunDir = arenaDir.CreateSubdirectory(DateTime.Now.ToString("s").Replace(" ", "-").ToValidFileName());
currentRunDir.Create();
var port = _startPort;
var cts = new CancellationTokenSource();
cancellationToken.Register(() => cts.Cancel());
while (true)
{
var generationProcessStartTime = DateTime.Now;
var generationDir = currentRunDir.CreateSubdirectory(generationNumber.ToString());
generationDir.Create();
var newGeneration = _generationGenerator.Genetic(lastGeneration);
lastGeneration = new List <Gene>();
var competitionTasks = new List <Task>();
switch (competetionMode)
{
case CompetetionMode.NoContainer:
await cleanSystem(cancellationToken);
break;
case CompetetionMode.ContainerPerCompetetion:
await DockerService.StopAndRemoveAllContainersAsync(cancellationToken);
break;
case CompetetionMode.ReusableContainer:
break;
}
Console.WriteLine($"running generation #{generationNumber}");
Console.WriteLine($"this generation will have {newGeneration.Count} genes and we'll process up to {_geneProcessLimit} genes simultaneously");
Console.WriteLine("-----------");
Console.WriteLine("no.\tsuccess\tscore\t\tid\t\telapsed\t\tsystem elapsed\t\tPPM\t\tcurrent time");
foreach (var gene in newGeneration)
{
competitionTasks.AddThreadSafe(processGene(gene, mapPath, lastGeneration, port, generationDir, competetionMode, cancellationToken));
port++;
}
await Task.WhenAll(competitionTasks).CancelOnFaulted(cts);
var generationInfoFilePath = Path.Combine(generationDir.FullName, "generationInfo.json");
await File.WriteAllTextAsync(generationInfoFilePath, JsonConvert.SerializeObject(newGeneration, Formatting.Indented), cancellationToken);
var generationScoreAverage = newGeneration.Average(x => x.Score);
Console.WriteLine($"generation score average: {generationScoreAverage}, generation elapsed time: {DateTime.Now - generationProcessStartTime}");
generationNumber++;
}
}
public HomeController(DockerService dockerService)
{
_dockerService = dockerService;
dockerService.MonitorEvents();
}
public HostController(DockerService dockerService)
{
_dockerService = dockerService;
}
public ContainerManagerController(DockerService dockerService, MySqlContainerService mysqlService)
{
_dockerService = dockerService;
_mysqlService = mysqlService;
}
