public async Task NodeStartupScript_UsesSuppliedBindingPort_EvenIfPortEnvironmentVariableValue_IsPresent()
{
// Arrange
var nodeVersion = "10.14";
var appName = "webfrontend";
var hostDir = Path.Combine(_hostSamplesDir, "nodejs", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var script = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"export PORT=9095")
.AddCommand($"oryx -appPath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"oryx",
new[] { "build", appDir, "-l", "nodejs", "--language-version", nodeVersion },
$"oryxdevms/node-{nodeVersion}",
ContainerPort,
"/bin/sh",
new[]
{
"-c",
script
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Say It Again", data);
});
}
public async Task CanBuildAndRun_ShapelyFlaskApp_PackageDir(string pythonVersion)
{
// Arrange
const string packageDir = "orx_packages";
var appName = "shapely-flask-app";
var hostDir = Path.Combine(_hostSamplesDir, "python", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var script = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"oryx -appPath {appDir} -bindPort {ContainerPort} -packagedir {packageDir}")
.AddCommand(DefaultStartupFilePath)
.ToString();
var imageVersion = "oryxdevms/python-" + pythonVersion;
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"oryx",
new[] { "build", appDir, "-l", "python", "--language-version", pythonVersion, "-p", $"packagedir={packageDir}" },
imageVersion,
ContainerPort,
"/bin/bash",
new[]
{
"-c",
script
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Hello Shapely, Area is: 314", data);
});
}
public async Task CanRun_NetCore30App_PublishedOnMacMachine_ButRunOnNetCore30RuntimeContainer()
{
// This test verifies that we fallback to using 'dotnet TodoAppFromMac.dll' since the executable
// file 'TodoAppFromMac' was indeed generated from a Mac OS and cannot be run in a Linux container.
// Arrange
var hostDir = Path.Combine(_hostSamplesDir, "DotNetCore", "TodoAppFromMac");
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var runtimeImageScript = new ShellScriptBuilder()
.AddCommand($"oryx -appPath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.RunAndAssertAppAsync(
"oryxdevms/dotnetcore-3.0",
_output,
new List <DockerVolume>() { volume },
environmentVariables : null,
ContainerPort,
link : null,
"/bin/sh",
new[]
{
"-c",
runtimeImageScript
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Hello World!", data);
},
new DockerCli());
}
public async Task CanBuildAndRun_NetCore11WebApp_HavingExplicitAssemblyName()
{
// Arrange
var appName = "NetCoreApp11WithExplicitAssemblyName";
var dotnetcoreVersion = "1.1";
var hostDir = Path.Combine(_hostSamplesDir, "DotNetCore", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var portMapping = $"{HostPort}:{ContainerPort}";
var runtimeImageScript = new ShellScriptBuilder()
.AddCommand($"oryx -sourcePath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"oryx",
new[] { "build", appDir, "-l", "dotnet", "--language-version", dotnetcoreVersion },
$"oryxdevms/dotnetcore-{dotnetcoreVersion}",
portMapping,
"/bin/sh",
new[]
{
"-c",
runtimeImageScript
},
async() =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{HostPort}/");
Assert.Contains("Hello World!", data);
});
}
public async Task DotNetCoreStartupScript_UsesSuppliedBindingPort_EvenIfPortEnvironmentVariableValue_IsPresent()
{
// Arrange
var dotnetcoreVersion = "2.2";
var hostDir = Path.Combine(_hostSamplesDir, "DotNetCore", NetCoreApp22WebApp);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var portMapping = $"{HostPort}:{ContainerPort}";
var runtimeImageScript = new ShellScriptBuilder()
.AddCommand($"export PORT=9095")
.AddCommand($"oryx -sourcePath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
NetCoreApp22WebApp,
_output,
volume,
"oryx",
new[] { "build", appDir, "-l", "dotnet", "--language-version", dotnetcoreVersion },
$"oryxdevms/dotnetcore-{dotnetcoreVersion}",
portMapping,
"/bin/sh",
new[]
{
"-c",
runtimeImageScript
},
async() =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{HostPort}/");
Assert.Contains("Hello World!", data);
});
}
public async Task PythonStartupScript_UsesSuppliedBindingPort_EvenIfPortEnvironmentVariableValue_IsPresent()
{
// Arrange
var appName = "flask-app";
var hostDir = Path.Combine(_hostSamplesDir, "python", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var script = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"export PORT=9095")
.AddCommand($"oryx -appPath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"oryx",
new[] { "build", appDir },
"oryxdevms/python-3.7",
ContainerPort,
"/bin/bash",
new[]
{
"-c",
script
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Hello World!", data);
});
}
public async Task Node_Lab2AppServiceApp()
{
// Arrange
var appName = "lab2-appservice";
var nodeVersion = "10.14";
var hostDir = Path.Combine(_hostSamplesDir, "nodejs", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var script = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"oryx -appPath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"oryx",
new[] { "build", appDir, "-l", "nodejs", "--language-version", nodeVersion },
$"oryxdevms/node-{nodeVersion}",
ContainerPort,
"/bin/sh",
new[]
{
"-c",
script
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Welcome to Express", data);
});
}
public async Task CanBuildAndRunPythonApp_UsingPython37_AndVirtualEnv()
{
// Arrange
var appName = "flask-app";
var virtualEnvName = "antenv";
var hostDir = Path.Combine(_hostSamplesDir, "python", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var script = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"oryx -appPath {appDir} -bindPort {ContainerPort} -virtualEnvName {virtualEnvName}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"oryx",
new[] { "build", appDir, "-p", $"virtualenv_name={virtualEnvName}" },
"oryxdevms/python-3.7",
ContainerPort,
"/bin/bash",
new[]
{
"-c",
script
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Hello World!", data);
});
}
public async Task RunNodeAppUsingConfigYml(string nodeVersion)
{
var appName = "express-config-yaml";
var hostDir = Path.Combine(_hostSamplesDir, "nodejs", appName);
var volume = DockerVolume.Create(hostDir);
var dir = volume.ContainerDir;
int hostPort = 8585;
int containerPort = 80;
var runAppScript = new ShellScriptBuilder()
.AddCommand($"cd {dir}/app")
.AddCommand("npm install")
.AddCommand("cd ..")
.AddCommand($"oryx -bindPort {containerPort} -userStartupCommand config.yml")
.AddCommand("./run.sh")
.ToString();
await EndToEndTestHelper.RunAndAssertAppAsync(
imageName : $"oryxdevms/node-{nodeVersion}",
output : _output,
volumes : new List <DockerVolume> {
volume
},
environmentVariables : null,
portMapping : $"{hostPort}:{containerPort}",
link : null,
runCmd : "/bin/sh",
runArgs : new[] { "-c", runAppScript },
assertAction : async() =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Equal("Hello World from express!", data);
},
dockerCli : _dockerCli);
}
public async Task Node_CreateReactAppSample()
{
// Arrange
var appName = "create-react-app-sample";
var nodeVersion = "10.14";
var hostDir = Path.Combine(_hostSamplesDir, "nodejs", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var portMapping = $"{HostPort}:{ContainerPort}";
var script = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"oryx -appPath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"oryx",
new[] { "build", appDir, "-l", "nodejs", "--language-version", nodeVersion },
$"oryxdevms/node-{nodeVersion}",
portMapping,
"/bin/sh",
new[]
{
"-c",
script
},
async() =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{HostPort}/");
Assert.Contains("<title>React App</title>", data);
});
}
public async Task Node_CreateReactAppSample_singleImage()
{
// Arrange
var appName = "create-react-app-sample";
var nodeVersion = "10";
var hostDir = Path.Combine(_hostSamplesDir, "nodejs", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var portMapping = $"{HostPort}:{ContainerPort}";
var runScript = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"oryx run-script --appPath {appDir} --platform nodejs --platform-version {nodeVersion} --bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName : appName,
output : _output,
volume : volume,
buildCmd : "oryx",
buildArgs : new[] { "build", appDir, "-l", "nodejs", "--language-version", nodeVersion },
runtimeImageName : $"oryxdevms/build",
portMapping : portMapping,
runCmd : "/bin/sh",
runArgs : new[]
{
"-c",
runScript
},
assertAction : async() =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{HostPort}/");
Assert.Contains("<title>React App</title>", data);
});
}
public async Task Tweeter3_Python37()
{
// Arrange
var appName = "tweeter3";
var hostDir = Path.Combine(_hostSamplesDir, "python", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var containerPort = 8000;
var portMapping = $"{HostPort}:{containerPort}";
var script = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"oryx -appPath {appDir} -output {startupFilePath} -hostBind=\":{containerPort}\"")
.AddCommand(startupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"oryx",
new[] { "build", appDir },
"oryxdevms/python-3.7",
portMapping,
"/bin/bash",
new[]
{
"-c",
script
},
async() =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{HostPort}/");
Assert.Contains("logged in as: bob", data);
});
}
public async Task CanBuildAndRunNodeApp_UsingYarnForBuild_AndExplicitOutputFile()
{
// Arrange
var appName = "webfrontend-yarnlock";
var nodeVersion = "10.14";
var hostDir = Path.Combine(_hostSamplesDir, "nodejs", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var portMapping = $"{HostPort}:{ContainerPort}";
var startupFilePath = "/tmp/startup.sh";
var script = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"oryx -appPath {appDir} -output {startupFilePath} -bindPort {ContainerPort}")
.AddCommand(startupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"oryx", new[] { "build", appDir, "-l", "nodejs", "--language-version", nodeVersion },
$"oryxdevms/node-{nodeVersion}",
portMapping,
"/bin/sh", new[] { "-c", script },
async() =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{HostPort}/");
Assert.Contains("Say It Again", data);
});
}
public void MultiPlatformBuild_IsDisabled()
{
// Arrange
var appName = "dotnetreact";
var hostDir = Path.Combine(_hostSamplesDir, "multilanguage", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var appOutputDir = $"{appDir}/myoutputdir";
var buildScript = new ShellScriptBuilder()
.AddCommand("export ENABLE_MULTIPLATFORM_BUILD=true")
.AddBuildCommand($"{appDir} -o {appOutputDir} -l dotnet --language-version 2.2")
.ToString();
// Act
var result = _dockerCli.Run(
Settings.BuildImageName,
SampleAppsTestBase.CreateAppNameEnvVar(appName),
volume,
commandToExecuteOnRun: "/bin/bash",
commandArguments:
new[]
{
"-c",
buildScript
});
// Assert
RunAsserts(
() =>
{
Assert.True(result.IsSuccess);
Assert.DoesNotContain(@"npm install", result.StdOut);
},
result.GetDebugInfo());
}
public async Task FlaskApp_Python36()
{
// Arrange
var appName = "flask-app";
var hostDir = Path.Combine(_hostSamplesDir, "python", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var portMapping = $"{HostPort}:5000";
var script = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"oryx -appPath {appDir} -output {startupFilePath} -hostBind=:5000")
.AddCommand(startupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"oryx",
new[] { "build", appDir, "-l", "python", "--language-version", "3.6" },
"oryxdevms/python-3.6",
portMapping,
"/bin/bash",
new[]
{
"-c",
script
},
async() =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{HostPort}/");
Assert.Contains("Hello World!", data);
});
}
public async Task RunNodeAppUsingProcessJson_withDebugging(string nodeVersion)
{
var appName = "express-process-json";
var hostDir = Path.Combine(_hostSamplesDir, "nodejs", appName);
var volume = DockerVolume.Create(hostDir);
var dir = volume.ContainerDir;
int hostPort = 8585;
int containerDebugPort = 8080;
var runAppScript = new ShellScriptBuilder()
.AddCommand($"cd {dir}/app")
.AddCommand("npm install")
.AddCommand("cd ..")
.AddCommand($"oryx -remoteDebug -debugPort={containerDebugPort}")
.AddCommand("./run.sh")
.ToString();
await EndToEndTestHelper.RunAndAssertAppAsync(
imageName : $"oryxdevms/node-{nodeVersion}",
output : _output,
volumes : new List <DockerVolume> {
volume
},
environmentVariables : null,
portMapping : $"{hostPort}:{containerDebugPort}",
link : null,
runCmd : "/bin/sh",
runArgs : new[] { "-c", runAppScript },
assertAction : async() =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Say It Again", data);
},
dockerCli : _dockerCli);
}
// Twig does not support PHP < 7
public async Task TwigExample(string phpVersion)
{
// Arrange
var appName = "twig-example";
var hostDir = Path.Combine(_hostSamplesDir, "php", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var script = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"oryx -appPath {appDir} -output {RunScriptPath}")
.AddCommand(RunScriptPath)
.ToString();
// Act & Assert
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName, _output, volume,
"oryx", new[] { "build", appDir, "-l", "php", "--language-version", phpVersion },
$"oryxdevms/php-{phpVersion}",
ContainerPort,
"/bin/sh", new[] { "-c", script },
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("<h1>Hello World!</h1>", data);
});
}
public async Task CanBuildAndRun_Tweeter3App()
{
// Arrange
var appName = "tweeter3";
var hostDir = Path.Combine(_hostSamplesDir, "python", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var script = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"oryx -appPath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"oryx",
new[] { "build", appDir },
"oryxdevms/python-3.7",
ContainerPort,
"/bin/bash",
new[]
{
"-c",
script
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("logged in as: bob", data);
});
}
public async Task CanBuildAndRunPythonApp_UsingPython27_AndExplicitOutputStartupFile()
{
// Arrange
var appName = "python2-flask-app";
var hostDir = Path.Combine(_hostSamplesDir, "python", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var startupFile = "/tmp/startup.sh";
var script = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"oryx -appPath {appDir} -output {startupFile} -bindPort {ContainerPort}")
.AddCommand(startupFile)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"oryx",
new[] { "build", appDir, "-l", "python", "--language-version", "2.7" },
"oryxdevms/python-2.7",
ContainerPort,
"/bin/bash",
new[]
{
"-c",
script
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Hello World!", data);
});
}
public async Task CanBuildAndRunNodeApp_OnSecondBuild_AfterNotZippingNodeModules_InFirstBuild()
{
// NOTE:
// 1. Use intermediate directory(which here is local to container) to avoid errors like
// "tar: node_modules/form-data: file changed as we read it"
// related to zipping files on a folder which is volume mounted.
// 2. Use output directory within the container due to 'rsync'
// having issues with volume mounted directories
// Arrange
var appOutputDirPath = Directory.CreateDirectory(Path.Combine(_tempRootDir, Guid.NewGuid().ToString("N")))
.FullName;
var appOutputDirVolume = DockerVolume.Create(appOutputDirPath);
var appOutputDir = appOutputDirVolume.ContainerDir;
var nodeVersion = "10.14";
var appName = "webfrontend";
var hostDir = Path.Combine(_hostSamplesDir, "nodejs", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var portMapping = $"{HostPort}:{ContainerPort}";
var script = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"oryx -appPath {appOutputDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
var buildScript = new ShellScriptBuilder()
.AddCommand($"oryx build {appDir} -i /tmp/int -o /tmp/out -l nodejs --language-version {nodeVersion}")
.AddCommand(
$"oryx build {appDir} -i /tmp/int -o /tmp/out -l nodejs " +
$"--language-version {nodeVersion} -p compress_node_modules=tar-gz")
.AddCommand($"cp -rf /tmp/out/* {appOutputDir}")
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
new List <DockerVolume> {
appOutputDirVolume, volume
},
"/bin/sh",
new[]
{
"-c",
buildScript
},
$"oryxdevms/node-{nodeVersion}",
portMapping,
"/bin/sh",
new[]
{
"-c",
script
},
async() =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{HostPort}/");
Assert.Contains("Say It Again", data);
});
}
public async Task ImagickExample(string phpVersion)
{
// Arrange
var appName = "imagick-example";
var hostDir = Path.Combine(_hostSamplesDir, "php", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var runScript = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"oryx -appPath {appDir} -output {RunScriptPath}")
.AddCommand(RunScriptPath)
.ToString();
// Act & Assert
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName, _output, volume,
"oryx", new[] { "build", appDir, "-l", "php", "--language-version", phpVersion },
$"oryxdevms/php-{phpVersion}",
$"{HostPort}:80",
"/bin/sh", new[] { "-c", runScript },
async() =>
{
string imagickOutput = await _httpClient.GetStringAsync($"http://localhost:{HostPort}/");
Assert.Equal("64x64", imagickOutput);
});
}
public async Task CanBuildAndRun_NodeApp_WithAppInsights_Configured(string nodeVersion)
{
// Arrange
var appName = "linxnodeexpress";
var hostDir = Path.Combine(_hostSamplesDir, "nodejs", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var portMapping = $"{HostPort}:{ContainerPort}";
var spcifyNodeVersionCommand = "-l nodejs --language-version=" + nodeVersion;
var aIKey = "APPINSIGHTS_INSTRUMENTATIONKEY";
var buildScript = new ShellScriptBuilder()
.AddCommand($"oryx build {appDir} -o {appDir} {spcifyNodeVersionCommand} --log-file {appDir}/1.log")
.AddDirectoryExistsCheck($"{appDir}/node_modules")
.AddFileExistsCheck($"{appDir}/oryx-appinsightsloader.js")
.AddFileExistsCheck($"{appDir}/oryx-manifest.toml")
.AddStringExistsInFileCheck("injectedAppInsights=\"True\"", $"{appDir}/oryx-manifest.toml")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"export {aIKey}=asdas")
.AddCommand($"cd {appDir}")
.AddCommand($"oryx -appPath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.AddFileExistsCheck($"{appDir}/oryx-appinsightsloader.js")
.AddFileExistsCheck($"{appDir}/oryx-manifest.toml")
.AddStringExistsInFileCheck("injectedAppInsights=\"True\"", $"{appDir}/oryx-manifest.toml")
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
new List <DockerVolume> {
volume
},
"/bin/bash",
new[]
{
"-c",
buildScript
},
$"oryxdevms/node-{nodeVersion}",
new List <EnvironmentVariable> {
new EnvironmentVariable(aIKey, "asdasda")
},
portMapping,
"/bin/sh",
new[]
{
"-c",
runScript
},
async() =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{HostPort}/");
Assert.Contains("Hello World from express!", data);
});
}
public async Task CanBuildAndRunNodeApp_UsingZippedNodeModules(string compressFormat, string nodeVersion)
{
// NOTE:
// 1. Use intermediate directory(which here is local to container) to avoid errors like
// "tar: node_modules/form-data: file changed as we read it"
// related to zipping files on a folder which is volume mounted.
// 2. Use output directory within the container due to 'rsync'
// having issues with volume mounted directories
// Arrange
var appOutputDirPath = Directory.CreateDirectory(Path.Combine(_tempRootDir, Guid.NewGuid().ToString("N")))
.FullName;
var appOutputDirVolume = DockerVolume.Create(appOutputDirPath);
var appOutputDir = appOutputDirVolume.ContainerDir;
var appName = "linxnodeexpress";
var hostDir = Path.Combine(_hostSamplesDir, "nodejs", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var runAppScript = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"oryx -appPath {appOutputDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
var buildScript = new ShellScriptBuilder()
.AddCommand(
$"oryx build {appDir} -i /tmp/int -o /tmp/out -l nodejs " +
$"--language-version {nodeVersion} -p compress_node_modules={compressFormat}")
.AddCommand($"cp -rf /tmp/out/* {appOutputDir}")
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
new List <DockerVolume> {
appOutputDirVolume, volume
},
"/bin/sh",
new[]
{
"-c",
buildScript
},
$"oryxdevms/node-{nodeVersion}",
ContainerPort,
"/bin/sh",
new[]
{
"-c",
runAppScript
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Equal("Hello World from express!", data);
});
}
public async Task GeneratesScript_CanRun_AppInsightsModule_NotFound(string nodeVersion)
{
// This test is for the following scenario:
// When we find injectedAppInsight=True in the manifest file, we assume that appinsights
// has been injected and it's installed during build (npm install). But for some reason if we
// don't see the appinsights node_module we shouldn't break the app. We should run the app
// and additionally print the exception message
// Arrange
var imageName = string.Concat("oryxdevms/node-", nodeVersion);
var hostSamplesDir = Path.Combine(Directory.GetCurrentDirectory(), "SampleApps");
var volume = DockerVolume.Create(Path.Combine(hostSamplesDir, "nodejs", "linxnodeexpress"));
var appDir = volume.ContainerDir;
var manifestFileContent = "injectedAppInsight=\"True\"";
var aiNodesdkLoaderContent = @"try {
var appInsights = require('applicationinsights');
if (process.env.APPINSIGHTS_INSTRUMENTATIONKEY)
{
appInsights.setup().start();
}
}catch (e) {
console.log(e);
} ";
int hostPort = 8585;
int containerDebugPort = 8080;
var script = new ShellScriptBuilder()
.CreateFile(appDir + "/oryx-manifest.toml", manifestFileContent)
.CreateFile(appDir + "/oryx-appinsightsloader.js", aiNodesdkLoaderContent)
.AddCommand($"cd {appDir}")
.AddCommand("npm install")
.AddCommand($"oryx -appPath {appDir}")
.AddDirectoryExistsCheck($"{appDir}/node_modules")
.AddDirectoryDoesNotExistCheck($"{appDir}/node_modules/applicationinsights")
.AddCommand("./run.sh")
.ToString();
await EndToEndTestHelper.RunAndAssertAppAsync(
imageName : $"oryxdevms/node-{nodeVersion}",
output : _output,
volumes : new List <DockerVolume> {
volume
},
environmentVariables : null,
portMapping : $"{hostPort}:{containerDebugPort}",
link : null,
runCmd : "/bin/sh",
runArgs : new[] { "-c", script },
assertAction : async() =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Hello World from express!", data);
},
dockerCli : _dockerCli);
}
public async Task CanBuildAndRunPythonApp_UsingPython37_AndCompressedVirtualEnv(
string compressOption,
string expectedCompressFileNameExtension)
{
// Arrange
var appName = "flask-app";
var virtualEnvName = "antenv";
var hostDir = Path.Combine(_hostSamplesDir, "python", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var portMapping = $"{HostPort}:{ContainerPort}";
var appOutputDirPath = Directory.CreateDirectory(
Path.Combine(_tempRootDir, Guid.NewGuid().ToString("N"))).FullName;
var appOutputDirVolume = DockerVolume.Create(appOutputDirPath);
var appOutputDir = appOutputDirVolume.ContainerDir;
var tempOutputDir = "/tmp/output";
var buildScript = new ShellScriptBuilder()
.AddCommand(
$"oryx build {appDir} -i /tmp/int -o {tempOutputDir}" +
$" -p virtualenv_name={virtualEnvName} -p compress_virtualenv={compressOption}")
.AddDirectoryDoesNotExistCheck($"{tempOutputDir}/{virtualEnvName}")
.AddFileExistsCheck($"{tempOutputDir}/{virtualEnvName}.{expectedCompressFileNameExtension}")
.AddCommand($"cp -rf {tempOutputDir}/* {appOutputDir}")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"oryx -appPath {appOutputDir} -bindPort {ContainerPort} -virtualEnvName {virtualEnvName}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
new List <DockerVolume> {
appOutputDirVolume, volume
},
"/bin/bash",
new[]
{
"-c",
buildScript
},
"oryxdevms/python-3.7",
portMapping,
"/bin/bash",
new[]
{
"-c",
runScript
},
async() =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{HostPort}/");
Assert.Contains("Hello World!", data);
});
}
protected async Task RunTestAsync(
string language,
string languageVersion,
string samplePath,
string databaseServerContainerName)
{
var volume = DockerVolume.Create(samplePath);
var appDir = volume.ContainerDir;
var portMapping = $"{HostPort}:8000";
var entrypointScript = "./start.sh";
var script = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"oryx -appPath {appDir} -output {entrypointScript}")
.AddCommand(entrypointScript)
.ToString();
var runtimeImageName = $"oryxdevms/{language}-{languageVersion}";
if (string.Equals(language, "nodejs", StringComparison.OrdinalIgnoreCase))
{
runtimeImageName = $"oryxdevms/node-{languageVersion}";
}
// For SqlLite scenarios where there is no database container, there wouldn't be any link
string link = null;
if (!string.IsNullOrEmpty(databaseServerContainerName))
{
link = $"{databaseServerContainerName}:{Constants.InternalDbLinkName}";
}
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
OutputHelper,
volume,
"oryx",
new[] { "build", appDir, "-l", language, "--language-version", languageVersion },
runtimeImageName,
new List <EnvironmentVariable>() { new EnvironmentVariable(Constants.DatabaseUserPwdEnvVar, Constants.DatabaseUserPwd) },
portMapping,
link,
"/bin/sh",
new[]
{
"-c",
script
},
async() =>
{
var data = await HttpClient.GetStringAsync($"http://localhost:{HostPort}/");
// Python samples are appending newline character at the end of their response.
data = data.TrimEnd('\n');
Assert.Equal(expectedOutput, data);
});
}
public async Task CanRun_SelfContainedApp_TargetedForLinux()
{
// ****************************************************************
// A self-contained app is an app which does not depend on whether a .NET Core runtime is present on the
// target machine or not. It has all the required dependencies (.dlls etc.) in its published output itself,
// hence it is called self-contained app.
//
// To test if our runtime images run self-contained apps correctly (i.e not using the dotnet runtime
// installed in the runtime image itself), in this test we publish a self-contained 3.0 app and run it in
// a 1.1 runtime container. This is because 1.1 runtime container does not have 3.0 bits at all and hence
// if the app fails to run in that container, then we are doing something wrong. If all is well, this 3.0
// app should run fine.
// ****************************************************************
// Arrange
var hostDir = Path.Combine(_hostSamplesDir, "DotNetCore", NetCoreApp30WebApp);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var appOutputDir = $"{appDir}/myoutputdir";
var buildImageScript = new ShellScriptBuilder()
.AddCommand($"source benv dotnet=3")
.AddCommand($"cd {appDir}")
.AddCommand($"dotnet publish -c release -r linux-x64 -o {appOutputDir}")
.ToString();
var runtimeImageScript = new ShellScriptBuilder()
.AddCommand(
$"oryx -appPath {appOutputDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
NetCoreApp30WebApp,
_output,
volume,
"/bin/bash",
new[]
{
"-c",
buildImageScript
},
"oryxdevms/dotnetcore-1.1",
ContainerPort,
"/bin/sh",
new[]
{
"-c",
runtimeImageScript
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Hello World!", data);
});
}
public async Task CanBuildAndRunNodeApp_WithDebugger(string nodeVersion)
{
// Arrange
var appOutputDirPath = Directory.CreateDirectory(Path.Combine(_tempRootDir, Guid.NewGuid().ToString("N")))
.FullName;
var appOutputDirVolume = DockerVolume.Create(appOutputDirPath);
var appOutputDir = appOutputDirVolume.ContainerDir;
var appName = "linxnodeexpress";
var hostDir = Path.Combine(_hostSamplesDir, "nodejs", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
const int localPort = 9393;
const int containerDebugPort = 9595;
var portMapping = $"{localPort}:{containerDebugPort}";
var runAppScript = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"oryx -appPath {appOutputDir} -remoteDebug -debugPort {containerDebugPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
var buildScript = new ShellScriptBuilder()
.AddCommand(
$"oryx build {appDir} -i /tmp/int -o /tmp/out -l nodejs " +
$"--language-version {nodeVersion} -p compress_node_modules=tar-gz")
.AddCommand($"cp -rf /tmp/out/* {appOutputDir}")
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
new List <DockerVolume> {
appOutputDirVolume, volume
},
"/bin/sh",
new[]
{
"-c",
buildScript
},
$"oryxdevms/node-{nodeVersion}",
portMapping,
"/bin/sh",
new[]
{
"-c",
runAppScript
},
async() =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{localPort}/json/list");
Assert.Contains("devtoolsFrontendUrl", data);
});
}
public async Task CanBuildAndRun_NetCore21WebApp_UsingExplicitStartupCommand()
{
// Arrange
var dotnetcoreVersion = "2.1";
var hostDir = Path.Combine(_hostSamplesDir, "DotNetCore", NetCoreApp21WebApp);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var portMapping = $"{HostPort}:{ContainerPort}";
var startupFilePath = "/tmp/run.sh";
var startupCommand = "\"dotnet foo.dll\"";
var appOutputDir = $"{appDir}/myoutputdir";
var buildImageScript = new ShellScriptBuilder()
.AddCommand($"oryx build {appDir} -l dotnet --language-version {dotnetcoreVersion} -o {appOutputDir}")
.ToString();
var runtimeImageScript = new ShellScriptBuilder()
.AddCommand(
$"cp {appOutputDir}/{NetCoreApp21WebApp}.dll {appOutputDir}/foo.dll")
.AddCommand($"rm -f {appOutputDir}/{NetCoreApp21WebApp}.dll")
.AddCommand(
$"cp {appOutputDir}/{NetCoreApp21WebApp}.runtimeconfig.json {appOutputDir}/foo.runtimeconfig.json")
.AddCommand($"rm -f {appOutputDir}/{NetCoreApp21WebApp}.runtimeconfig.json")
.AddCommand(
$"oryx -appPath {appOutputDir} -output {startupFilePath} " +
$"-userStartupCommand {startupCommand} -bindPort {ContainerPort}")
.AddCommand(startupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
NetCoreApp21WebApp,
_output,
volume,
"/bin/sh",
new[]
{
"-c",
buildImageScript
},
$"oryxdevms/dotnetcore-{dotnetcoreVersion}",
portMapping,
"/bin/sh",
new[]
{
"-c",
runtimeImageScript
},
async() =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{HostPort}/");
Assert.Contains("Hello World!", data);
});
}
public async Task CanBuildAndRun_DjangoPython36App_UsingVirtualEnv()
{
// Arrange
var appName = "django-app";
var hostDir = Path.Combine(_hostSamplesDir, "python", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var portMapping = $"{HostPort}:{ContainerPort}";
const string virtualEnvName = "antenv3.6";
var buildScript = new ShellScriptBuilder()
.AddBuildCommand($"{appDir} -l python --language-version 3.6 -p virtualenv_name={virtualEnvName}")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"oryx -appPath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"/bin/bash",
new[]
{
"-c",
buildScript
},
"oryxdevms/python-3.6",
portMapping,
"/bin/bash",
new[]
{
"-c",
runScript
},
async() =>
{
var data = await GetResponseDataAsync($"http://localhost:{HostPort}/staticfiles/css/boards.css");
Assert.Contains("CSS file from Boards app module", data);
data = await GetResponseDataAsync($"http://localhost:{HostPort}/staticfiles/css/uservoice.css");
Assert.Contains("CSS file from UserVoice app module", data);
data = await GetResponseDataAsync($"http://localhost:{HostPort}/boards/");
Assert.Contains("Hello, World! from Boards app", data);
data = await GetResponseDataAsync($"http://localhost:{HostPort}/uservoice/");
Assert.Contains("Hello, World! from Uservoice app", data);
});
}
