public Task VerifyListenMode(MonitorImageData imageData, SampleImageData sampleData)
{
return(VerifyScenarioAsync(
monitorImageData: imageData,
sampleImageData: sampleData,
shareTmpVolume: false,
listenDiagPortVolume: true,
noAuthentication: true,
async(monitorName, sampleName) =>
{
if (!Config.IsHttpVerificationDisabled)
{
using HttpResponseMessage responseMessage =
await ImageScenarioVerifier.GetHttpResponseFromContainerAsync(
monitorName,
DockerHelper,
OutputHelper,
DefaultArtifactsPort,
UrlPath_Processes);
JsonElement rootElement = GetContentAsJsonElement(responseMessage);
// Verify returns an array with one element (the sample container process)
Assert.Equal(JsonValueKind.Array, rootElement.ValueKind);
Assert.Equal(1, rootElement.GetArrayLength());
}
}));
}
public Task VerifyMonitorNoHttpsNoAuth(MonitorImageData imageData)
{
return(VerifyMonitorAsync(
imageData,
noAuthentication: true,
async containerName =>
{
if (!Config.IsHttpVerificationDisabled)
{
// Verify metrics endpoint is accessible and produces zero processes
using HttpResponseMessage processesMessage =
await ImageScenarioVerifier.GetHttpResponseFromContainerAsync(
containerName,
DockerHelper,
OutputHelper,
DefaultArtifactsPort,
UrlPath_Processes);
JsonElement rootElement = GetContentAsJsonElement(processesMessage);
// Verify returns an empty array (should not detect any processes)
Assert.Equal(JsonValueKind.Array, rootElement.ValueKind);
Assert.Equal(0, rootElement.GetArrayLength());
}
},
builder =>
{
// Reset and expose the artifacts port over http (not secure)
builder.MonitorUrl(DefaultArtifactsPort);
}));
}
public Task VerifyMonitorNoHttps(MonitorImageData imageData)
{
return(VerifyMonitorAsync(
imageData,
noAuthentication: false,
async containerName =>
{
if (!Config.IsHttpVerificationDisabled)
{
// Verify processes returns 401 (Unauthorized) since authentication was not provided.
using HttpResponseMessage processesMessage =
await ImageScenarioVerifier.GetHttpResponseFromContainerAsync(
containerName,
DockerHelper,
OutputHelper,
DefaultArtifactsPort,
UrlPath_Processes,
m => VerifyStatusCode(m, HttpStatusCode.Unauthorized));
}
},
builder =>
{
// Reset and expose the artifacts port over http (not secure)
builder.MonitorUrl(DefaultArtifactsPort);
}));
}
/// <summary>
/// Runs a single instance of the dotnet-monitor image.
/// </summary>
/// <param name="imageData">The image data of the dotnet-monitor image.</param>
/// <param name="noAuthentication">Set to true to disable dotnet-monitor authenication.</param>
/// <param name="verifyContainerAsync">Callback to test some aspect of the container.</param>
/// <param name="runArgsCallback">Allows for modifying the "docker run" args of the container.</param>
private async Task VerifyMonitorAsync(
MonitorImageData imageData,
bool noAuthentication,
Func <string, Task> verifyContainerAsync = null,
Action <DockerRunArgsBuilder> runArgsCallback = null)
{
GetNames(imageData, out string monitorImageName, out string monitorContainerName);
try
{
DockerRunArgsBuilder runArgsBuilder = DockerRunArgsBuilder.Create()
.ExposePort(DefaultMetricsPort);
if (null != runArgsCallback)
{
runArgsCallback(runArgsBuilder);
}
DockerHelper.Run(
image: monitorImageName,
name: monitorContainerName,
command: GetMonitorAdditionalArgs(noAuthentication),
detach: true,
optionalRunArgs: runArgsBuilder.Build());
if (!Config.IsHttpVerificationDisabled)
{
// Verify metrics endpoint is accessible
using HttpResponseMessage metricsMessage =
await ImageScenarioVerifier.GetHttpResponseFromContainerAsync(
monitorContainerName,
DockerHelper,
OutputHelper,
DefaultMetricsPort,
UrlPath_Metrics);
string metricsContent = await metricsMessage.Content.ReadAsStringAsync();
// Metrics should not return any content if
// no processes are detected.
Assert.Equal(string.Empty, metricsContent);
}
if (null != verifyContainerAsync)
{
await verifyContainerAsync(monitorContainerName);
}
}
finally
{
DockerHelper.DeleteContainer(monitorContainerName);
}
}
public void VerifyEnvironmentVariables(MonitorImageData imageData)
{
List <EnvironmentVariableInfo> variables = new List <EnvironmentVariableInfo>();
variables.AddRange(ProductImageTests.GetCommonEnvironmentVariables());
// ASPNETCORE_URLS has been unset to allow the default URL binding to occur.
variables.Add(new EnvironmentVariableInfo("ASPNETCORE_URLS", string.Empty));
// Diagnostics should be disabled
variables.Add(new EnvironmentVariableInfo("COMPlus_EnableDiagnostics", "0"));
EnvironmentVariableInfo.Validate(
variables,
imageData.GetImage(DockerHelper),
imageData,
DockerHelper);
}
public void VerifyEnvironmentVariables(MonitorImageData imageData)
{
List <EnvironmentVariableInfo> variables = new List <EnvironmentVariableInfo>();
variables.AddRange(ProductImageTests.GetCommonEnvironmentVariables());
// ASPNETCORE_URLS has been unset to allow the default URL binding to occur.
variables.Add(new EnvironmentVariableInfo("ASPNETCORE_URLS", string.Empty));
// Diagnostics should be disabled
variables.Add(new EnvironmentVariableInfo("COMPlus_EnableDiagnostics", "0"));
// DefaultProcess filter should select a process with a process ID of 1
variables.Add(new EnvironmentVariableInfo("DefaultProcess__Filters__0__Key", "ProcessId"));
variables.Add(new EnvironmentVariableInfo("DefaultProcess__Filters__0__Value", "1"));
// Console logger format should be JSON and output UTC timestamps without timezone information
variables.Add(new EnvironmentVariableInfo("Logging__Console__FormatterName", "json"));
variables.Add(new EnvironmentVariableInfo("Logging__Console__FormatterOptions__TimestampFormat", "yyyy-MM-ddTHH:mm:ss.fffffffZ"));
variables.Add(new EnvironmentVariableInfo("Logging__Console__FormatterOptions__UseUtcTimestamp", "true"));
EnvironmentVariableInfo.Validate(
variables,
imageData.GetImage(DockerHelper),
imageData,
DockerHelper);
}
private void GetNames(MonitorImageData imageData, out string imageName, out string containerName)
{
imageName = imageData.GetImage(DockerHelper);
containerName = imageData.GetIdentifier("monitortest");
}
private static SampleImageData GetSampleImageData(MonitorImageData imageData)
{
return(TestData.GetSampleImageData()
.First(d => d.IsPublished = true && d.Arch == imageData.Arch));
}
/// <summary>
/// Runs a single instance of each of the dotnet-monitor and samples images.
/// </summary>
/// <param name="monitorImageData">The image data of the dotnet-monitor image.</param>
/// <param name="shareTmpVolume">Set to true to mount the /tmp directory in both containers.</param>
/// <param name="listenDiagPortVolume">
/// Set to true to have the monitor container listen with a diagnostic port listener
/// for diagnostic connections from the samples container.
/// </param>
/// <param name="noAuthentication">Set to true to disable dotnet-monitor authenication.</param>
/// <param name="verifyContainerAsync">Callback to test some aspect of the containers.</param>
/// <param name="monitorRunArgsCallback">Allows for modifying the "docker run" args of the dotnet-monitor container.</param>
/// <param name="sampleRunArgsCallback">Allows for modifying the "docker run" args of the samples container.</param>
private async Task VerifyScenarioAsync(
MonitorImageData monitorImageData,
SampleImageData sampleImageData,
bool shareTmpVolume,
bool listenDiagPortVolume,
bool noAuthentication,
Func <string, string, Task> verifyContainerAsync,
Action <DockerRunArgsBuilder> monitorRunArgsCallback = null,
Action <DockerRunArgsBuilder> sampleRunArgsCallback = null)
{
GetNames(monitorImageData, out string monitorImageName, out string monitorContainerName);
GetNames(sampleImageData, out string sampleImageName, out string sampleContainerName);
DockerRunArgsBuilder monitorArgsBuilder = DockerRunArgsBuilder.Create()
.MonitorUrl(DefaultArtifactsPort);
DockerRunArgsBuilder sampleArgsBuilder = DockerRunArgsBuilder.Create()
.ExposePort(DefaultHttpPort);
string diagPortVolumeName = null;
string tmpVolumeName = null;
try
{
// Create a volume for the two containers to share the /tmp directory.
if (shareTmpVolume)
{
tmpVolumeName = DockerHelper.CreateVolume(UniqueName("tmpvol"));
monitorArgsBuilder.VolumeMount(tmpVolumeName, Directory_Tmp);
sampleArgsBuilder.VolumeMount(tmpVolumeName, Directory_Tmp);
}
// Create a volume so that the dotnet-monitor container can provide a
// diagnostic listening port to the samples container so that the samples
// process can connect to the dotnet-monitor process.
if (listenDiagPortVolume)
{
diagPortVolumeName = DockerHelper.CreateVolume(UniqueName("diagportvol"));
monitorArgsBuilder.VolumeMount(diagPortVolumeName, Directory_Diag);
monitorArgsBuilder.MonitorListen(File_DiagPort);
sampleArgsBuilder.VolumeMount(diagPortVolumeName, Directory_Diag);
sampleArgsBuilder.RuntimeSuspend(File_DiagPort);
}
// Allow modification of the "docker run" args of the monitor container
if (null != monitorRunArgsCallback)
{
monitorRunArgsCallback(monitorArgsBuilder);
}
// Allow modification of the "docker run" args of the samples container
if (null != sampleRunArgsCallback)
{
sampleRunArgsCallback(sampleArgsBuilder);
}
// Run the sample container
DockerHelper.Run(
image: sampleImageName,
name: sampleContainerName,
detach: true,
optionalRunArgs: sampleArgsBuilder.Build());
// Run the dotnet-monitor container
DockerHelper.Run(
image: monitorImageName,
name: monitorContainerName,
command: GetMonitorAdditionalArgs(noAuthentication),
detach: true,
optionalRunArgs: monitorArgsBuilder.Build());
await verifyContainerAsync(
monitorContainerName,
sampleContainerName);
}
finally
{
DockerHelper.DeleteContainer(monitorContainerName);
DockerHelper.DeleteContainer(sampleContainerName);
if (!string.IsNullOrEmpty(diagPortVolumeName))
{
DockerHelper.DeleteVolume(diagPortVolumeName);
}
if (!string.IsNullOrEmpty(tmpVolumeName))
{
DockerHelper.DeleteVolume(tmpVolumeName);
}
}
}
public Task VerifyMonitorDefault(MonitorImageData imageData)
{
return(VerifyMonitorAsync(imageData, noAuthentication: false));
}
