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));
}
