/// <summary>
/// Used for diagnostic info, ex: docker info
/// </summary>
/// <returns>system info</returns>
public async Task <SystemInfoResponse> DockerInfo()
{
SystemInfoResponse response = new SystemInfoResponse();
response = await client.Miscellaneous.GetSystemInfoAsync();
return(response);
}
public async static Task <RuntimeInfoProvider> CreateAsync(IDockerClient client)
{
Preconditions.CheckNotNull(client, nameof(client));
// get system information from docker
SystemInfoResponse info = await client.System.GetSystemInfoAsync();
return(new RuntimeInfoProvider(client, info.OSType, info.Architecture));
}
public void InspectResponseToModuleTest()
{
const string StatusText = "Running for 1 second";
DateTime lastStartTime = DateTime.Parse("2017-08-04T17:52:13.0419502Z", null, DateTimeStyles.RoundtripKind);
DateTime lastExitTime = lastStartTime.AddDays(1);
// Arrange
string id = Guid.NewGuid().ToString();
string hash = Guid.NewGuid().ToString();
var inspectContainerResponse = new ContainerInspectResponse
{
State = new ContainerState
{
Status = StatusText,
ExitCode = 0,
StartedAt = lastStartTime.ToString("o"),
FinishedAt = lastExitTime.ToString("o"),
},
Name = "/sensor",
Image = hash,
Config = new Config {
Image = "ubuntu"
}
};
var systemInfoResponse = new SystemInfoResponse
{
OSType = OperatingSystemType,
Architecture = Architecture
};
var dockerClient = Mock.Of <IDockerClient>(
dc =>
dc.Containers == Mock.Of <IContainerOperations>(co => co.InspectContainerAsync(id, default(CancellationToken)) == Task.FromResult(inspectContainerResponse)) &&
dc.System == Mock.Of <ISystemOperations>(so => so.GetSystemInfoAsync(default(CancellationToken)) == Task.FromResult(systemInfoResponse)));
// Act
ModuleRuntimeInfo module = RuntimeInfoProvider.InspectResponseToModule(inspectContainerResponse);
// Assert
Assert.NotNull(module);
var dockerModule = module as ModuleRuntimeInfo <DockerReportedConfig>;
Assert.NotNull(dockerModule);
Assert.Equal("ubuntu:latest", dockerModule.Config.Image);
Assert.Equal("sensor", dockerModule.Name);
Assert.Equal(0, dockerModule.ExitCode);
Assert.Equal(StatusText, dockerModule.Description);
Assert.Equal(lastStartTime, dockerModule.StartTime.OrDefault());
Assert.Equal(lastExitTime, dockerModule.ExitTime.OrDefault());
}
private IDockerClient SetupDockerClient(string nonExistingContainer, params string[] containers)
{
var dockerClient = new Mock <IDockerClient>();
var dockerContainer = new Mock <IContainerOperations>();
var dockerSystem = new Mock <ISystemOperations>();
var containerList = containers.Select(c => new ContainerListResponse {
ID = c
}).ToList();
var systemInfoResponse = new SystemInfoResponse()
{
OSType = OperatingSystemType, Architecture = Architecture, ServerVersion = "42"
};
dockerClient.Setup(call => call.Containers).Returns(dockerContainer.Object);
dockerClient.Setup(call => call.System).Returns(dockerSystem.Object);
dockerContainer.Setup(
call => call.ListContainersAsync(It.IsAny <ContainersListParameters>(), It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult(containerList as IList <ContainerListResponse>));
dockerContainer.Setup(
call => call.InspectContainerAsync(It.IsAny <string>(), It.IsAny <CancellationToken>()))
.Returns(
(string a, CancellationToken b) =>
{
if (a.Equals(nonExistingContainer))
{
return(Task.FromException <ContainerInspectResponse>(new DockerContainerNotFoundException(0, null)));
}
else
{
return(Task.FromResult(new ContainerInspectResponse()
{
Name = "/" + a,
Config = new Config()
{
Image = "dummy:latest"
},
State = new ContainerState()
{
Status = "running"
}
}));
}
});
dockerSystem.Setup(
call => call.GetSystemInfoAsync(It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult(systemInfoResponse));
return(dockerClient.Object);
}
public async Task TestPlatformInfo()
{
using (var cts = new CancellationTokenSource(Timeout))
{
// Arrange
SystemInfoResponse systemInfo = await Client.System.GetSystemInfoAsync(cts.Token);
RuntimeInfoProvider runtimeInfoProvider = await RuntimeInfoProvider.CreateAsync(Client);
// Act
SystemInfo recivedSystemInfo = await runtimeInfoProvider.GetSystemInfo();
// Assert
Assert.Equal(systemInfo.OSType, recivedSystemInfo.OperatingSystemType);
Assert.Equal(systemInfo.Architecture, recivedSystemInfo.Architecture);
}
}
public async Task GetSystemInfoTest()
{
// Arrange
var systemInfoResponse = new SystemInfoResponse
{
OSType = OperatingSystemType,
Architecture = Architecture
};
var dockerClient = Mock.Of <IDockerClient>(
dc =>
dc.System == Mock.Of <ISystemOperations>(so => so.GetSystemInfoAsync(default(CancellationToken)) == Task.FromResult(systemInfoResponse)));
// Act
var runtimeInfoProvider = await RuntimeInfoProvider.CreateAsync(dockerClient);
SystemInfo systemInfo = await runtimeInfoProvider.GetSystemInfo(CancellationToken.None);
// Assert
Assert.NotNull(systemInfo);
Assert.Equal(systemInfo.OperatingSystemType, systemInfoResponse.OSType);
Assert.Equal(systemInfo.Architecture, systemInfoResponse.Architecture);
}
public async Task GetModuleLogsTest()
{
// Arrange
string id = "mod1";
string dummyLogs = new string('*', 1000);
Stream GetLogsStream() => new MemoryStream(Encoding.UTF8.GetBytes(dummyLogs));
var systemInfoResponse = new SystemInfoResponse
{
OSType = OperatingSystemType,
Architecture = Architecture
};
ContainerLogsParameters receivedContainerLogsParameters = null;
var containerOperations = new Mock <IContainerOperations>();
containerOperations.Setup(co => co.GetContainerLogsAsync(id, It.IsAny <ContainerLogsParameters>(), It.IsAny <CancellationToken>()))
.Callback <string, ContainerLogsParameters, CancellationToken>((m, c, t) => receivedContainerLogsParameters = c)
.ReturnsAsync(GetLogsStream);
var dockerClient = Mock.Of <IDockerClient>(
dc =>
dc.Containers == containerOperations.Object &&
dc.System == Mock.Of <ISystemOperations>(so => so.GetSystemInfoAsync(default(CancellationToken)) == Task.FromResult(systemInfoResponse)));
var runtimeInfoProvider = await RuntimeInfoProvider.CreateAsync(dockerClient);
// Act
Stream receivedLogsStream = await runtimeInfoProvider.GetModuleLogs(id, false, Option.None <int>(), Option.None <string>(), Option.None <string>(), Option.None <bool>(), CancellationToken.None);
// Assert
Assert.NotNull(receivedContainerLogsParameters);
Assert.False(receivedContainerLogsParameters.Follow);
Assert.Null(receivedContainerLogsParameters.Tail);
Assert.Null(receivedContainerLogsParameters.Since);
Assert.True(receivedContainerLogsParameters.ShowStderr);
Assert.True(receivedContainerLogsParameters.ShowStdout);
var buffer = new byte[1024];
int readBytes = await receivedLogsStream.ReadAsync(buffer);
Assert.Equal(1000, readBytes);
string receivedLogs = Encoding.UTF8.GetString(buffer, 0, readBytes);
Assert.Equal(dummyLogs, receivedLogs);
// Act
receivedLogsStream = await runtimeInfoProvider.GetModuleLogs(id, true, Option.Some(1000), Option.None <string>(), Option.None <string>(), Option.None <bool>(), CancellationToken.None);
// Assert
Assert.NotNull(receivedContainerLogsParameters);
Assert.True(receivedContainerLogsParameters.Follow);
Assert.Equal("1000", receivedContainerLogsParameters.Tail);
Assert.Null(receivedContainerLogsParameters.Since);
Assert.True(receivedContainerLogsParameters.ShowStderr);
Assert.True(receivedContainerLogsParameters.ShowStdout);
buffer = new byte[1024];
readBytes = await receivedLogsStream.ReadAsync(buffer);
Assert.Equal(1000, readBytes);
receivedLogs = Encoding.UTF8.GetString(buffer, 0, readBytes);
Assert.Equal(dummyLogs, receivedLogs);
// Act
receivedLogsStream = await runtimeInfoProvider.GetModuleLogs(id, true, Option.None <int>(), Option.Some("1552887267"), Option.None <string>(), Option.None <bool>(), CancellationToken.None);
// Assert
Assert.NotNull(receivedContainerLogsParameters);
Assert.True(receivedContainerLogsParameters.Follow);
Assert.Null(receivedContainerLogsParameters.Tail);
Assert.Equal("1552887267", receivedContainerLogsParameters.Since);
Assert.True(receivedContainerLogsParameters.ShowStderr);
Assert.True(receivedContainerLogsParameters.ShowStdout);
buffer = new byte[1024];
readBytes = await receivedLogsStream.ReadAsync(buffer);
Assert.Equal(1000, readBytes);
receivedLogs = Encoding.UTF8.GetString(buffer, 0, readBytes);
Assert.Equal(dummyLogs, receivedLogs);
}
