Example #1
0
 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();
        }
Example #3
0
        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;
            });
        }
Example #4
0
        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");
        }
Example #6
0
        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;
 }
Example #8
0
        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();
        }
Example #10
0
 public ContainersViewModel(DockerService docker)
 {
     docker.Containers
     .Connect()
     .Select(x => new ContainerViewModel(docker, x))
     .ObserveOn(RxApp.MainThreadScheduler)
     .Bind(out _containers)
     .Subscribe();
 }
Example #11
0
        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();
            }
        }
Example #12
0
        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);
 }
Example #16
0
 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) !;
 }
Example #17
0
        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.");
            }
        }
Example #18
0
        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);
        }
Example #19
0
 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.");
     }
 }
Example #20
0
        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();
        }
Example #21
0
 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)
             );
     });
 }
Example #22
0
        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);
        }
Example #23
0
        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);
        }
Example #24
0
        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;
        }
Example #26
0
        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.");
            }
        }
Example #27
0
        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++;
            }
        }
Example #28
0
 public HomeController(DockerService dockerService)
 {
     _dockerService = dockerService;
     dockerService.MonitorEvents();
 }
Example #29
0
 public HostController(DockerService dockerService)
 {
     _dockerService = dockerService;
 }
Example #30
0
 public ContainerManagerController(DockerService dockerService, MySqlContainerService mysqlService)
 {
     _dockerService = dockerService;
     _mysqlService  = mysqlService;
 }