private async Task SetHostToInactive(DockerHost host) { Guard.Against.Null(host, nameof(host)); if (host.AWSHost == null || host.AzureHost == null) { return; } //If Host has been from created resources then set to inactive and used host.Active = false; host.Used = true; await _dockerHostRepo.UpdateAsync(host); }
public void ImageIsExposedOnARunningContainer() { using (var container = DockerHost.Create("postgres:9.6-alpine", new ContainerCreateParams { Environment = new[] { "POSTGRES_PASSWORD=mysecretpassword" } })) { var config = container.GetConfiguration(); var image = container.Image.GetConfiguration(); Assert.AreEqual(config.Image, image.Id); } }
public INetworkService Attach(string containerId, bool detatchOnDisposeNetwork, string alias = null) { var aliasArray = alias != null ? new string[] { alias } : null; if (detatchOnDisposeNetwork) { _detatchOnDispose.Add(containerId); } DockerHost.NetworkConnect(containerId, Id, certificates: Certificates, alias: aliasArray); return(this); }
public void Remove(bool force = false) { if (State != ServiceRunningState.Stopped) { Stop(); } State = ServiceRunningState.Removing; var result = DockerHost.RemoveContainer(Id, force, false, null, _certificates); if (result.Success) { State = ServiceRunningState.Removed; } }
public Volume GetConfiguration(bool fresh = false) { if (!fresh && null != _config) { return(_config); } var result = DockerHost.VolumeInspect(certificates: Certificates, volume: Name); if (!result.Success) { throw new FluentDockerException($"Could not run docker volume inspect for volume name: {Name}"); } return(_config = result.Data[0]); }
public NetworkConfiguration GetConfiguration(bool fresh = false) { if (!fresh && null != _config) { return(_config); } var result = DockerHost.NetworkInspect(certificates: Certificates, network: Id); if (!result.Success) { throw new FluentDockerException($"Could not run docker network inspect on network id: {Id}"); } return(_config = result.Data); }
private async Task <DockerHost> CreateAzureHost(CreateOptimizedExperimentCommand request, Guid templateId) { var template = await _azureVMRepo.GetByIdAsync(templateId); var dockerHost = new DockerHost { Name = request.Name, Location = "Ireland", CloudProvider = Enums.CloudProvider.Azure, HostName = "localhost", vCPU = template.vCPUs, Memory = template.Memory, PortNumber = 2376, Storage = template.DiskSize }; var azureRegion = Region.Values.Where(c => c.Name.ToLower() == "westeurope".ToLower()).FirstOrDefault(); var creds = _azureCredsRepo.GetAll().FirstOrDefault(); var azureHost = new AzureHost { DockerHost = dockerHost, AzureRegion = azureRegion.ToString(), DestroyResourcesAfterBenchmark = true, Credentials = creds, IPAddress = "127.0.0.1", Template = template, Name = "AzureHost" + request.Name.Replace(" ", "", StringComparison.CurrentCulture) + DateTime.Now.Ticks }; dockerHost.AzureHost = azureHost; await _dockerHostRepo.AddAsync(dockerHost); return(dockerHost); }
public async Task UpdateDockerHostAsync(DockerHost entity) { if (entity.Active == false) { await _dockerHostRepo.UpdateAsync(entity); return; } if (entity.AWSHost != null || entity.AWSHost != null) { await _dockerHostRepo.UpdateAsync(entity); return; } bool pingDockerHost; if (entity.UseHttpAuthentication) { pingDockerHost = await PingDockerHost(entity.HostName, entity.PortNumber, entity.UserName, entity.Password); } else { pingDockerHost = await PingDockerHost(entity.HostName, entity.PortNumber); } if (pingDockerHost) { await _dockerHostRepo.UpdateAsync(entity); } else { throw new Exception("Can't connect to Docker Host, check host details"); } }
public override void Remove(bool force = false) { State = ServiceRunningState.Removing; DockerHost.VolumeRm(Certificates, force, Name); State = ServiceRunningState.Removed; }
private async Task <Entities.BenchmarkExperiment> CreateExperiment(DockerHost host, DockerHost benchmarkHost, CreateOptimizedExperimentCommand request) { var name = request.Name + DateTime.Now.Ticks; if (host.AWSHost != null) { request.Name += host.AWSHost.Template.VMSizeType; } else { request.Name += host.AzureHost.Template.VMSizeType; } var experiment = new Entities.BenchmarkExperiment { Name = name, ExperimentReference = request.ExperimentReference, BenchmarkingName = request.BenchmarkingName, Application = await _applicationRepo.GetByIdAsync(request.Application), ApdexTSeconds = request.ApdexTSeconds, ApacheJmeterTestId = request.ApacheTestFileId, TestFile = await _apacheTestFileRepo.GetByIdAsync(request.ApacheTestFileId), Variables = _mapper.Map <List <BenchmarkExperimentVariable> >(request.Variables), Host = host, BenchmarkHost = benchmarkHost }; await _benchmarkRepo.AddAsync(experiment); return(experiment); }
public INetworkService Detatch(string containerId, bool force = false) { _detatchOnDispose.Remove(containerId); DockerHost.NetworkDisconnect(containerId, Id, force, Certificates); return(this); }
private async Task <string> LaunchImageToHost(DockerImage image, DockerHost host, IEnumerable <ApplicationTestVariable> applicationVariables = null) { Guard.Against.Null(image, nameof(image)); Guard.Against.Null(host, nameof(host)); if (host.UseHttpAuthentication) { CreateBasicHttpClient(host.HostName, host.PortNumber, host.UserName, host.Password, out _dockerAppClient); } else { CreateClientNoAuthentication(host.HostName, host.PortNumber, out _dockerAppClient); } await RemoveContainersFromHost(_dockerAppClient); await PullImageOntoHost(image, HostType.Application); var portBindings = new Dictionary <string, IList <PortBinding> >(); if (image.ImageType == ImageType.Application || image.ImageType == ImageType.Database) { if (image.ExternalPort == null) { throw new NullReferenceException("External Port must be exposed when launching web-application container."); } if (image.InternalPort == null) { throw new NullReferenceException("Internal Port must be exposed when launching web-application container."); } } var startParamters = new CreateContainerParameters() { Name = image.DockerFriendlyName, Image = image.FullImageTag, HostConfig = new HostConfig { PortBindings = new Dictionary <string, IList <PortBinding> >() { { image.InternalPort + "/tcp", new PortBinding[] { new PortBinding { HostIP = "0.0.0.0", HostPort = image.ExternalPort.ToString() } } } } }, ExposedPorts = new Dictionary <string, EmptyStruct>() }; var environmentalVariablesList = new List <string>(); foreach (var variable in image.Variables) { var variableString = variable.Name + "=" + variable.Value; environmentalVariablesList.Add(variableString); } if (image.ImageType == ImageType.Application) { if (applicationVariables != null) { foreach (var variable in applicationVariables) { var variableString = variable.Name + "=" + variable.Value; environmentalVariablesList.Add(variableString); } } } startParamters.Env = environmentalVariablesList; startParamters.ExposedPorts.Add(image.InternalPort + "/tcp", default(EmptyStruct)); var container = await _dockerAppClient.Containers.CreateContainerAsync(startParamters); bool task = await _dockerAppClient.Containers.StartContainerAsync(container.ID, new ContainerStartParameters(), CancellationToken.None); if (task) { return(container.ID); } throw new Exception("Error Starting Benchmark Container: " + container.ID); }
public async Task <IList <ContainerListResponse> > ViewRunningContainers(DockerHost host) { Guard.Against.Null(host, nameof(host)); return(await _dockerClient.Containers.ListContainersAsync(new ContainersListParameters { All = false }, CancellationToken.None)); }