public async Task WhenCommandSucceeds_ResultContainsTruncatedContainerId()
{
// Arrange
var mockDockerClient = BuildMockDockerClient(true, true);
var fullContainerId = "thisislongerthantwelvecharacters";
var mockCommand = MotherFor.CommandWrapper
.ThatSucceeds()
.WithOutput(fullContainerId)
.Build();
var mockCommandFactory = MotherFor.CommandFactory
.ForWorkingDirectory(_workingDirectory)
.ForCommandReturn(DockerCommands.Image.RunContainer(ExpectedId, null), mockCommand)
.Build();
var dockerImage = new DockerImageResult
{
Id = ExpectedId,
Repository = ExpectedRepository,
Tag = ExpectedTag
};
var expectedResult = new DockerContainer(mockDockerClient, mockCommandFactory, "thisislonger", new DockerPortMapping[0]);
var sut = new DockerImage(mockDockerClient, mockCommandFactory, dockerImage);
// Act
var result = await sut.StartContainerAsync();
// Assert
result.Should().BeEquivalentTo(expectedResult);
}
public DockerContainerLifetimeAction(DockerContainer dockerContainer, string title, string startDescription, string endDescription, string action)
: base(dockerContainer.Connection, title, startDescription)
{
this.endDescription = endDescription;
this.dockerContainer = dockerContainer;
this.action = action;
}
public DockerContainerLifetimeAction(DockerContainer dockerContainer, string title, string startDescription, string endDescription, string action)
: base(dockerContainer.Connection, title, startDescription)
{
this.endDescription = endDescription;
this.dockerContainer = dockerContainer;
this.action = action;
}
public ResumeDockerContainerAction(DockerContainer dockerContainer)
: base(dockerContainer,
string.Format(Messages.ACTION_RESUME_CONTAINER_TITLE, dockerContainer.Name),
Messages.ACTION_RESUME_CONTAINER_DESCRIPTION,
Messages.ACTION_RESUME_CONTAINER_END_DESCRIPTION,
"unpause")
{
}
public StartDockerContainerAction(DockerContainer dockerContainer)
: base(dockerContainer,
string.Format(Messages.ACTION_START_CONTAINER_TITLE, dockerContainer.Name),
Messages.ACTION_START_CONTAINER_DESCRIPTION,
Messages.ACTION_START_CONTAINER_END_DESCRIPTION,
"start")
{
}
public PauseDockerContainerAction(DockerContainer dockerContainer)
: base(dockerContainer,
string.Format(Messages.ACTION_PAUSE_CONTAINER_TITLE, dockerContainer.Name()),
Messages.ACTION_PAUSE_CONTAINER_DESCRIPTION,
Messages.ACTION_PAUSE_CONTAINER_END_DESCRIPTION,
"pause")
{
}
public StopDockerContainerAction(DockerContainer dockerContainer)
: base(dockerContainer,
string.Format(Messages.ACTION_STOP_CONTAINER_TITLE, dockerContainer.Name()),
Messages.ACTION_STOP_CONTAINER_DESCRIPTION,
Messages.ACTION_STOP_CONTAINER_END_DESCRIPTION,
"stop")
{
}
public PauseDockerContainerAction(DockerContainer dockerContainer)
: base(dockerContainer,
string.Format(Messages.ACTION_PAUSE_CONTAINER_TITLE, dockerContainer.Name),
Messages.ACTION_PAUSE_CONTAINER_DESCRIPTION,
Messages.ACTION_PAUSE_CONTAINER_END_DESCRIPTION,
"pause")
{
}
public DockerContainerViewModel(DockerContainer container, DockerInstance instance)
{
_container = container;
_containerName = container.Name;
_containerState = container.State;
Host = instance.Host;
StartAsyncCommand = new AsyncCommand(StartAsyncCommandHandler);
StopAsyncCommand = new AsyncCommand(StopAsyncCommandHandler);
}
public override bool IsValid(SelectedItemCollection selection)
{
if (selection.Count == 1)
{
DockerContainer dockerContainer = selection[0].XenObject as DockerContainer;
return(dockerContainer != null);
}
return(false);
}
public DockerContainerViewModel(DockerService service, DockerContainer container)
{
Service = service;
Container = container;
Id = container.Id;
Update();
EnableLogsCommand = new BasicCommand(() => Service.Connected, o => service.EnableLogs(Id));
}
public override void Build(IMainWindow mainWindow, SelectedItemCollection selection, ContextMenuItemCollection items)
{
DockerContainer vm = (DockerContainer)selection[0].XenObject;
items.AddIfEnabled(new StartDockerContainerCommand(mainWindow, selection));
items.AddIfEnabled(new StopDockerContainerCommand(mainWindow, selection));
items.AddIfEnabled(new PauseDockerContainerCommand(mainWindow, selection));
items.AddIfEnabled(new ResumeDockerContainerCommand(mainWindow, selection));
items.AddIfEnabled(new RestartDockerContainerCommand(mainWindow, selection));
}
private Color GetContainerStateColor(DockerContainer container)
{
switch (container.State)
{
case "exited":
return(Color.LightPink);
default:
return(Color.White);
}
}
public bool Start()
{
_container = new DockerContainerBuilder(new DockerContainerBuilderOptions
{
FromImage = "microsoft/mssql-server-linux",
Tag = "latest",
Name = "mssql-evolve",
Env = new[] { $"ACCEPT_EULA=Y", $"SA_PASSWORD={DbPwd}" },
ExposedPort = $"{ExposedPort}/tcp",
HostPort = HostPort
}).Build();
return(_container.Start());
}
public static Icons GetIconFor(DockerContainer dockerContainer)
{
switch (dockerContainer.power_state)
{
case vm_power_state.Paused:
return(Icons.DCPaused);
case vm_power_state.Running:
return(Icons.DCRunning);
default:
return(Icons.DCStopped);
}
}
public async Task DeleteContainer(DockerContainer container)
{
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
await Client.Containers.RemoveContainerAsync(container.Id,
new ContainerRemoveParameters
{
Force = true,
//RemoveLinks = true,
//RemoveVolumes = true
});
}
public void WhenDeleted_DoesNotCallMonitorStatsForCommand()
{
// Arrange
var mockDockerClient = Substitute.For <IDockerClient>();
var mockCommandFactory = Substitute.For <IRunCommands>();
var sut = new DockerContainer(mockDockerClient, mockCommandFactory, ExpectedId, new DockerPortMapping[0])
{
Deleted = true
};
// Act
Assert.CatchAsync(async() => await sut.MonitorStatsFor(TimeSpan.Zero));
// Assert
mockCommandFactory.DidNotReceive().RunCommand(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <CancellationToken?>());
}
public void WhenDeleted_ThrowsDockerContainerDeletedException()
{
// Arrange
var mockDockerClient = Substitute.For <IDockerClient>();
var mockCommandFactory = Substitute.For <IRunCommands>();
var sut = new DockerContainer(mockDockerClient, mockCommandFactory, ExpectedId, new DockerPortMapping[0])
{
Deleted = true
};
// Act
var exception = Assert.CatchAsync(async() => await sut.RemoveAsync());
// Assert
exception.Should().BeOfType <DockerContainerDeletedException>();
}
public void WhenDeleted_DoesNotCallContainerExists()
{
// Arrange
var mockDockerClient = Substitute.For <IDockerClient>();
var mockCommandFactory = Substitute.For <IRunCommands>();
var sut = new DockerContainer(mockDockerClient, mockCommandFactory, ExpectedId, new DockerPortMapping[0])
{
Deleted = true
};
// Act
Assert.CatchAsync(async() => await sut.RemoveAsync());
// Assert
mockDockerClient.DidNotReceive().ContainerExistsAsync(Arg.Any <string>());
}
private void RenderNetworks(DockerContainer container)
{
containerNetworks.Items.Clear();
foreach (KeyValuePair <string, EndpointSettings> network in container.NetworkSettings)
{
containerNetworks.Items.Add(
new ListViewItem(new[]
{
network.Key,
$"{network.Value.IPAddress} ({network.Value.IPPrefixLen})",
network.Value.NetworkID,
network.Value.EndpointID,
network.Value.MacAddress
}));
}
containerNetworks.AutoAlign();
tabNetworks.Text = $"Networks ({container.NetworkSettings.Count})";
}
public DockerMsSqlServerDatabase(string databaseName)
{
_databaseName = databaseName;
var ports = new Dictionary <int, int>
{
{ 1433, Port }
};
_sqlServerContainer = new DockerContainer(
Image,
Tag,
HealthCheck,
ports)
{
ContainerName = "sql-stream-store-tests-mssql",
Env = new[] { "ACCEPT_EULA=Y", $"SA_PASSWORD={Password}" }
};
}
public void WhenRemoveFails_ThrowsDockerCommandException()
{
// Arrange
var mockDockerClient = BuildMockDockerClient(true, true);
var mockCommand = MotherFor.CommandWrapper.ThatFails().WithExitCode(-1).Build();
var mockCommandFactory = MotherFor.CommandFactory
.ForWorkingDirectory(_workingDirectory)
.ForCommandReturn(DockerCommands.Container.Remove(ExpectedId), mockCommand)
.Build();
var sut = new DockerContainer(mockDockerClient, mockCommandFactory, ExpectedId, new DockerPortMapping[0]);
// Act
var exception = Assert.CatchAsync(async() => await sut.RemoveAsync());
// Assert
exception.Should().BeOfType <DockerCommandException>();
}
public PostgresDockerDatabaseManager(
ITestOutputHelper testOutputHelper,
string databaseName,
int tcpPort = 5432)
: base(testOutputHelper, databaseName)
{
_tcpPort = tcpPort;
_postgresContainer = new DockerContainer(
DockerImage,
DockerTag,
HealthCheck,
new Dictionary <int, int>
{
[tcpPort] = tcpPort
})
{
ContainerName = ContainerName,
Cmd = new [] { "-N", "500" }
};
}
public async Task WhenRemoveFails_CallsContainerExists()
{
// Arrange
var mockDockerClient = BuildMockDockerClient(true, true);
var mockCommand = MotherFor.CommandWrapper.ThatFails().WithExitCode(-1).Build();
var mockCommandFactory = MotherFor.CommandFactory
.ForWorkingDirectory(_workingDirectory)
.ForCommandReturn(DockerCommands.Container.Remove(ExpectedId), mockCommand)
.Build();
var sut = new DockerContainer(mockDockerClient, mockCommandFactory, ExpectedId, new DockerPortMapping[0]);
// Act
Assert.CatchAsync(async() => await sut.RemoveAsync());
// Assert
await mockDockerClient.Received(1).ContainerExistsAsync(Arg.Any <string>());
}
public async Task WhenRemoveSucceeds_ItSetsDeleted()
{
// Arrange
var mockDockerClient = BuildMockDockerClient(true, true);
var mockCommand = MotherFor.CommandWrapper.ThatSucceeds().Build();
var mockCommandFactory = MotherFor.CommandFactory
.ForWorkingDirectory(_workingDirectory)
.ForCommandReturn(DockerCommands.Container.Remove(ExpectedId), mockCommand)
.Build();
var sut = new DockerContainer(mockDockerClient, mockCommandFactory, ExpectedId, new DockerPortMapping[0]);
// Act
await sut.RemoveAsync();
// Assert
sut.Deleted.Should().BeTrue();
}
public async Task WhenRemoveSucceeds_DoesNotCallContainerExists()
{
// Arrange
var mockDockerClient = BuildMockDockerClient(true, true);
var mockCommand = MotherFor.CommandWrapper.ThatSucceeds().Build();
var mockCommandFactory = MotherFor.CommandFactory
.ForWorkingDirectory(_workingDirectory)
.ForCommandReturn(DockerCommands.Container.Remove(ExpectedId), mockCommand)
.Build();
var sut = new DockerContainer(mockDockerClient, mockCommandFactory, ExpectedId, new DockerPortMapping[0]);
// Act
await sut.RemoveAsync();
// Assert
await mockDockerClient.DidNotReceive().ContainerExistsAsync(Arg.Any <string>());
}
public void WhenContainerExistsFails_ItDoesNotSetDeletedState()
{
// Arrange
var mockDockerClient = BuildMockDockerClient(false, true);
var mockCommand = MotherFor.CommandWrapper.ThatFails().WithExitCode(-1).Build();
var mockCommandFactory = MotherFor.CommandFactory
.ForWorkingDirectory(_workingDirectory)
.ForCommandReturn(DockerCommands.Container.Remove(ExpectedId), mockCommand)
.Build();
var sut = new DockerContainer(mockDockerClient, mockCommandFactory, ExpectedId, new DockerPortMapping[0]);
// Act
Assert.CatchAsync(async() => await sut.RemoveAsync());
// Assert
sut.Deleted.Should().BeFalse();
}
public void WhenContainerExistsSucceeds_ItSetsDeletedState()
{
// Arrange
var mockDockerClient = BuildMockDockerClient(true, false);
var mockCommand = MotherFor.CommandWrapper.ThatFails().WithExitCode(-1).Build();
var mockCommandFactory = MotherFor.CommandFactory
.ForWorkingDirectory(_workingDirectory)
.ForCommandReturn(DockerCommands.Container.GetStats(ExpectedId), mockCommand)
.Build();
var sut = new DockerContainer(mockDockerClient, mockCommandFactory, ExpectedId, new DockerPortMapping[0]);
// Act
Assert.CatchAsync(async() => await sut.MonitorStatsFor(TimeSpan.Zero));
// Assert
sut.Deleted.Should().BeTrue();
}
public async Task WhenNotDeleted_CallsRemoveCommand()
{
// Arrange
var mockDockerClient = BuildMockDockerClient(true, true);
var mockCommand = MotherFor.CommandWrapper.ThatSucceeds().Build();
var mockCommandFactory = MotherFor.CommandFactory
.ForWorkingDirectory(_workingDirectory)
.ForCommandReturn(DockerCommands.Container.Remove(ExpectedId), mockCommand)
.Build();
var sut = new DockerContainer(mockDockerClient, mockCommandFactory, ExpectedId, new DockerPortMapping[0]);
// Act
await sut.RemoveAsync();
// Assert
mockCommandFactory.Received(1).RunCommand(DockerCommands.Container.Remove(ExpectedId), _workingDirectory, Arg.Any <CancellationToken?>());
}
public async Task WhenMonitorStatsForSucceeds_DoesNotCallContainerExists()
{
// Arrange
var mockDockerClient = BuildMockDockerClient(true, true);
var mockCommand = MotherFor.CommandWrapper.ThatSucceeds()
.WithOutput(MotherFor.ContainerStatsJson(1m, 1m).Build())
.Build();
var mockCommandFactory = MotherFor.CommandFactory
.ForWorkingDirectory(_workingDirectory)
.ForCommandReturn(DockerCommands.Container.GetStats(ExpectedId), mockCommand)
.Build();
var sut = new DockerContainer(mockDockerClient, mockCommandFactory, ExpectedId, new DockerPortMapping[0]);
// Act
await sut.MonitorStatsFor(TimeSpan.Zero);
// Assert
await mockDockerClient.DidNotReceive().ContainerExistsAsync(Arg.Any <string>());
}
public async Task WhenNotDeleted_CallsMonitorStatsForCommand()
{
// Arrange
var mockDockerClient = BuildMockDockerClient(true, true);
var mockCommand = MotherFor.CommandWrapper
.ThatSucceeds()
.WithOutput(MotherFor.ContainerStatsJson(1m, 1m).Build())
.Build();
var mockCommandFactory = MotherFor.CommandFactory
.ForWorkingDirectory(_workingDirectory)
.ForCommandReturn(DockerCommands.Container.GetStats(ExpectedId), mockCommand)
.Build();
var sut = new DockerContainer(mockDockerClient, mockCommandFactory, ExpectedId, new DockerPortMapping[0]);
// Act
await sut.MonitorStatsFor(TimeSpan.Zero);
// Assert
mockCommandFactory.Received().RunCommand(DockerCommands.Container.GetStats(ExpectedId), _workingDirectory, Arg.Any <CancellationToken?>());
}
public MySqlDockerDatabaseManager(
ITestOutputHelper testOutputHelper,
string databaseName,
int tcpPort = 3306)
: base(testOutputHelper, databaseName)
{
_tcpPort = tcpPort;
_mysqlContainer = new DockerContainer(
DockerImage,
DockerTag,
HealthCheck,
new Dictionary <int, int>
{
[tcpPort] = tcpPort
})
{
ContainerName = ContainerName,
Env = new[]
{
"MYSQL_ALLOW_EMPTY_PASSWORD=1"
}
};
}
private static bool CanExecute(DockerContainer dockerContainer)
{
return dockerContainer.power_state == vm_power_state.Halted;
}
private static bool CanExecute(DockerContainer dockerContainer)
{
return dockerContainer.power_state == vm_power_state.Running && !dockerContainer.Parent.IsWindows;
}
public StopDockerContainerAction(DockerContainer dockerContainer)
: base(dockerContainer,
string.Format(Messages.ACTION_STOP_CONTAINER_TITLE, dockerContainer.Name),
Messages.ACTION_STOP_CONTAINER_DESCRIPTION,
Messages.ACTION_STOP_CONTAINER_END_DESCRIPTION,
"stop")
{
}
public RestartDockerContainerAction(DockerContainer dockerContainer)
: base(dockerContainer,
string.Format(Messages.ACTION_RESTART_CONTAINER_TITLE, dockerContainer.Name),
Messages.ACTION_RESTART_CONTAINER_DESCRIPTION,
Messages.ACTION_RESTART_CONTAINER_END_DESCRIPTION,
"restart")
{
}
public ExecuteContainerPluginAction(DockerContainer container, Host host, string plugin, string function, Dictionary<string, string> args, bool suppressHistory)
: base(container.Connection, host, plugin, function, args, suppressHistory)
{
Container = container;
}
public static Icons GetIconFor(DockerContainer dockerContainer)
{
switch (dockerContainer.power_state)
{
case vm_power_state.Paused:
return Icons.DCPaused;
case vm_power_state.Running:
return Icons.DCRunning;
default:
return Icons.DCStopped;
}
}
private VirtualTreeNode AddDockerContainerNode(DockerContainer cont)
{
return AddNode(cont.Name.Ellipsise(1000), Images.GetIconFor(cont), cont.IsHidden, cont);
}
public static List<DockerContainer> GetContainersFromOtherConfig(VM vm)
{
var containers = new List<DockerContainer>();
var other_config = vm.other_config;
if (other_config.ContainsKey("docker_ps"))
{
XmlDocument doc = new XmlDocument();
doc.LoadXml(other_config["docker_ps"]);
foreach (XmlNode entry in doc.GetElementsByTagName("entry"))
{
//uuid
string id = "";
var propertyNode = entry.ChildNodes.Cast<XmlNode>().FirstOrDefault(node => node.Name == "id");
if (propertyNode != null)
id = propertyNode.InnerText;
string name = "";
propertyNode = entry.ChildNodes.Cast<XmlNode>().FirstOrDefault(node => node.Name == "names");
if (propertyNode != null)
name = propertyNode.InnerText;
string status = "";
propertyNode = entry.ChildNodes.Cast<XmlNode>().FirstOrDefault(node => node.Name == "status");
if (propertyNode != null)
status = propertyNode.InnerText;
string container = "";
propertyNode = entry.ChildNodes.Cast<XmlNode>().FirstOrDefault(node => node.Name == "container");
if (propertyNode != null)
container = propertyNode.InnerText;
string created = "";
propertyNode = entry.ChildNodes.Cast<XmlNode>().FirstOrDefault(node => node.Name == "created");
if (propertyNode != null)
created = propertyNode.InnerText;
string image = "";
propertyNode = entry.ChildNodes.Cast<XmlNode>().FirstOrDefault(node => node.Name == "image");
if (propertyNode != null)
image = propertyNode.InnerText;
string command = "";
propertyNode = entry.ChildNodes.Cast<XmlNode>().FirstOrDefault(node => node.Name == "command");
if (propertyNode != null)
command = propertyNode.InnerText;
string ports = "";
propertyNode = entry.ChildNodes.Cast<XmlNode>().FirstOrDefault(node => node.Name == "ports");
if (propertyNode != null)
ports = propertyNode.InnerXml;
DockerContainer newContainer = new DockerContainer(vm, id, name, string.Empty, status, container, created, image, command, ports);
// update existing container or add a new one
DockerContainer existingContainer = vm.Connection.Resolve(new XenRef<DockerContainer>(newContainer));
if (existingContainer != null)
{
existingContainer.UpdateFrom(newContainer);
containers.Add(existingContainer);
}
else
containers.Add(newContainer);
}
}
return containers;
}
