public static async Task <ApplicationBuilder> CreateAsync(OutputContext output, FileInfo source, string?framework = null, ApplicationFactoryFilter?filter = null)
{
if (source is null)
{
throw new ArgumentNullException(nameof(source));
}
var queue = new Queue <(ConfigApplication, HashSet <string>)>();
var visited = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
var rootConfig = ConfigFactory.FromFile(source);
rootConfig.Validate();
var root = new ApplicationBuilder(source, rootConfig.Name !);
root.Namespace = rootConfig.Namespace;
queue.Enqueue((rootConfig, new HashSet <string>()));
while (queue.Count > 0)
{
var item = queue.Dequeue();
var config = item.Item1;
// dependencies represents a set of all dependencies
var dependencies = item.Item2;
if (!visited.Add(config.Source.FullName))
{
continue;
}
if (config == rootConfig && !string.IsNullOrEmpty(config.Registry))
{
root.Registry = new ContainerRegistry(config.Registry);
}
if (config == rootConfig)
{
root.Network = rootConfig.Network;
}
foreach (var configExtension in config.Extensions)
{
var extension = new ExtensionConfiguration((string)configExtension["name"]);
foreach (var kvp in configExtension)
{
if (kvp.Key == "name")
{
continue;
}
extension.Data.Add(kvp.Key, kvp.Value);
}
root.Extensions.Add(extension);
}
var services = filter?.ServicesFilter != null?
config.Services.Where(filter.ServicesFilter).ToList() :
config.Services;
var sw = Stopwatch.StartNew();
// Project services will be restored and evaluated before resolving all other services.
// This batching will mitigate the performance cost of running MSBuild out of process.
var projectServices = services.Where(s => !string.IsNullOrEmpty(s.Project));
var projectMetadata = new Dictionary <string, string>();
var msbuildEvaluationResult = await EvaluateProjectsAsync(
projects : projectServices,
configRoot : config.Source.DirectoryName !,
output : output);
var msbuildEvaluationOutput = msbuildEvaluationResult
.StandardOutput
.Split(Environment.NewLine);
var multiTFMProjects = new List <ConfigService>();
foreach (var line in msbuildEvaluationOutput)
{
var trimmed = line.Trim();
if (trimmed.StartsWith("Microsoft.Tye metadata: "))
{
var values = line.Split(':', 3);
var projectName = values[1].Trim();
var metadataPath = values[2].Trim();
projectMetadata.Add(projectName, metadataPath);
output.WriteDebugLine($"Resolved metadata for service {projectName} at {metadataPath}");
}
else if (trimmed.StartsWith("Microsoft.Tye cross-targeting project: "))
{
var values = line.Split(':', 2);
var projectName = values[1].Trim();
var multiTFMConfigService = projectServices.First(p => string.Equals(p.Name, projectName, StringComparison.OrdinalIgnoreCase));
multiTFMConfigService.BuildProperties.Add(new BuildProperty {
Name = "TargetFramework", Value = framework ?? string.Empty
});
multiTFMProjects.Add(multiTFMConfigService);
}
}
if (multiTFMProjects.Any())
{
output.WriteDebugLine("Re-evaluating multi-targeted projects");
var multiTFMEvaluationResult = await EvaluateProjectsAsync(
projects : multiTFMProjects,
configRoot : config.Source.DirectoryName !,
output : output);
var multiTFMEvaluationOutput = multiTFMEvaluationResult
.StandardOutput
.Split(Environment.NewLine);
foreach (var line in multiTFMEvaluationOutput)
{
var trimmed = line.Trim();
if (trimmed.StartsWith("Microsoft.Tye metadata: "))
{
var values = line.Split(':', 3);
var projectName = values[1].Trim();
var metadataPath = values[2].Trim();
projectMetadata.Add(projectName, metadataPath);
output.WriteDebugLine($"Resolved metadata for service {projectName} at {metadataPath}");
}
else if (trimmed.StartsWith("Microsoft.Tye cross-targeting project: "))
{
var values = line.Split(':', 2);
var projectName = values[1].Trim();
throw new CommandException($"Unable to run {projectName}. Your project targets multiple frameworks. Specify which framework to run using '--framework' or a build property in tye.yaml.");
}
}
}
output.WriteDebugLine($"Restore and project evaluation took: {sw.Elapsed.TotalMilliseconds}ms");
foreach (var configService in services)
{
ServiceBuilder service;
if (root.Services.Any(s => s.Name == configService.Name))
{
// Even though this service has already created a service, we still need
// to update dependency information
AddToRootServices(root, dependencies, configService.Name);
continue;
}
if (!string.IsNullOrEmpty(configService.Project))
{
var project = new DotnetProjectServiceBuilder(configService.Name !, new FileInfo(configService.ProjectFullPath));
service = project;
project.Build = configService.Build ?? true;
project.Args = configService.Args;
foreach (var buildProperty in configService.BuildProperties)
{
project.BuildProperties.Add(buildProperty.Name, buildProperty.Value);
}
project.Replicas = configService.Replicas ?? 1;
project.Liveness = configService.Liveness != null?GetProbeBuilder(configService.Liveness) : null;
project.Readiness = configService.Readiness != null?GetProbeBuilder(configService.Readiness) : null;
// We don't apply more container defaults here because we might need
// to prompt for the registry name.
project.ContainerInfo = new ContainerInfo()
{
UseMultiphaseDockerfile = false,
};
// If project evaluation is successful this should not happen, therefore an exception will be thrown.
if (!projectMetadata.ContainsKey(configService.Name))
{
throw new CommandException($"Evaluated project metadata file could not be found for service {configService.Name}");
}
ProjectReader.ReadProjectDetails(output, project, projectMetadata[configService.Name]);
// Do k8s by default.
project.ManifestInfo = new KubernetesManifestInfo();
}
else if (!string.IsNullOrEmpty(configService.Image))
{
var container = new ContainerServiceBuilder(configService.Name !, configService.Image !)
{
Args = configService.Args,
Replicas = configService.Replicas ?? 1
};
service = container;
container.Liveness = configService.Liveness != null?GetProbeBuilder(configService.Liveness) : null;
container.Readiness = configService.Readiness != null?GetProbeBuilder(configService.Readiness) : null;
}
else if (!string.IsNullOrEmpty(configService.DockerFile))
{
var dockerFile = new DockerFileServiceBuilder(configService.Name !, configService.Image !)
{
Args = configService.Args,
Build = configService.Build ?? true,
Replicas = configService.Replicas ?? 1,
DockerFile = Path.Combine(source.DirectoryName !, configService.DockerFile),
// Supplying an absolute path with trailing slashes fails for DockerFileContext when calling docker build, so trim trailing slash.
DockerFileContext = GetDockerFileContext(source, configService),
BuildArgs = configService.DockerFileArgs
};
service = dockerFile;
dockerFile.Liveness = configService.Liveness != null?GetProbeBuilder(configService.Liveness) : null;
dockerFile.Readiness = configService.Readiness != null?GetProbeBuilder(configService.Readiness) : null;
// We don't apply more container defaults here because we might need
// to prompt for the registry name.
dockerFile.ContainerInfo = new ContainerInfo()
{
UseMultiphaseDockerfile = false,
};
// Do k8s by default.
dockerFile.ManifestInfo = new KubernetesManifestInfo();
}
else if (!string.IsNullOrEmpty(configService.Executable))
{
var expandedExecutable = Environment.ExpandEnvironmentVariables(configService.Executable);
var workingDirectory = "";
// Special handling of .dlls as executables (it will be executed as dotnet {dll})
if (Path.GetExtension(expandedExecutable) == ".dll")
{
expandedExecutable = Path.GetFullPath(Path.Combine(config.Source.Directory !.FullName, expandedExecutable));
workingDirectory = Path.GetDirectoryName(expandedExecutable) !;
}
var executable = new ExecutableServiceBuilder(configService.Name !, expandedExecutable)
{
Args = configService.Args,
WorkingDirectory = configService.WorkingDirectory != null?
Path.GetFullPath(Path.Combine(config.Source.Directory !.FullName, Environment.ExpandEnvironmentVariables(configService.WorkingDirectory))) :
workingDirectory,
Replicas = configService.Replicas ?? 1
};
service = executable;
executable.Liveness = configService.Liveness != null?GetProbeBuilder(configService.Liveness) : null;
executable.Readiness = configService.Readiness != null?GetProbeBuilder(configService.Readiness) : null;
}
else if (!string.IsNullOrEmpty(configService.Include))
{
var expandedYaml = Environment.ExpandEnvironmentVariables(configService.Include);
var nestedConfig = GetNestedConfig(rootConfig, Path.Combine(config.Source.DirectoryName !, expandedYaml));
queue.Enqueue((nestedConfig, new HashSet <string>()));
AddToRootServices(root, dependencies, configService.Name);
continue;
}
else if (!string.IsNullOrEmpty(configService.Repository))
{
// clone to .tye folder
var path = configService.CloneDirectory ?? Path.Join(rootConfig.Source.DirectoryName, ".tye", "deps");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
var clonePath = Path.Combine(path, configService.Name);
if (!Directory.Exists(clonePath))
{
if (!await GitDetector.Instance.IsGitInstalled.Value)
{
throw new CommandException($"Cannot clone repository {configService.Repository} because git is not installed. Please install git if you'd like to use \"repository\" in tye.yaml.");
}
var result = await ProcessUtil.RunAsync("git", $"clone {configService.Repository} \"{clonePath}\"", workingDirectory : path, throwOnError : false);
if (result.ExitCode != 0)
{
throw new CommandException($"Failed to clone repository {configService.Repository} with exit code {result.ExitCode}.{Environment.NewLine}{result.StandardError}{result.StandardOutput}.");
}
}
if (!ConfigFileFinder.TryFindSupportedFile(clonePath, out var file, out var errorMessage))
{
throw new CommandException(errorMessage !);
}
// pick different service type based on what is in the repo.
var nestedConfig = GetNestedConfig(rootConfig, file);
queue.Enqueue((nestedConfig, new HashSet <string>()));
AddToRootServices(root, dependencies, configService.Name);
continue;
}
else if (!string.IsNullOrEmpty(configService.AzureFunction))
{
var azureFunctionDirectory = Path.Combine(config.Source.DirectoryName !, configService.AzureFunction);
var functionBuilder = new AzureFunctionServiceBuilder(
configService.Name,
azureFunctionDirectory)
{
Args = configService.Args,
Replicas = configService.Replicas ?? 1,
FuncExecutablePath = configService.FuncExecutable,
};
foreach (var proj in Directory.EnumerateFiles(azureFunctionDirectory))
{
var fileInfo = new FileInfo(proj);
if (fileInfo.Extension == ".csproj" || fileInfo.Extension == ".fsproj")
{
functionBuilder.ProjectFile = fileInfo.FullName;
break;
}
}
// TODO liveness?
service = functionBuilder;
}
else if (configService.External)
{
var external = new ExternalServiceBuilder(configService.Name);
service = external;
}
else
{
throw new CommandException("Unable to determine service type.");
}
// Add dependencies to ourself before adding ourself to avoid self reference
service.Dependencies.UnionWith(dependencies);
AddToRootServices(root, dependencies, service.Name);
root.Services.Add(service);
// If there are no bindings and we're in ASP.NET Core project then add an HTTP and HTTPS binding
if (configService.Bindings.Count == 0 &&
service is ProjectServiceBuilder project2 &&
project2.IsAspNet)
{
// HTTP is the default binding
service.Bindings.Add(new BindingBuilder()
{
Protocol = "http"
});
service.Bindings.Add(new BindingBuilder()
{
Name = "https", Protocol = "https"
});
}
public static async Task <ApplicationBuilder> CreateAsync(OutputContext output, FileInfo source, string?framework = null, ApplicationFactoryFilter?filter = null)
{
if (source is null)
{
throw new ArgumentNullException(nameof(source));
}
var queue = new Queue <(ConfigApplication, HashSet <string>)>();
var visited = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
var rootConfig = ConfigFactory.FromFile(source);
rootConfig.Validate();
var root = new ApplicationBuilder(source, rootConfig.Name !);
root.Namespace = rootConfig.Namespace;
queue.Enqueue((rootConfig, new HashSet <string>()));
while (queue.Count > 0)
{
var item = queue.Dequeue();
var config = item.Item1;
// dependencies represents a set of all dependencies
var dependencies = item.Item2;
if (!visited.Add(config.Source.FullName))
{
continue;
}
if (config == rootConfig && !string.IsNullOrEmpty(config.Registry))
{
root.Registry = new ContainerRegistry(config.Registry);
}
if (config == rootConfig)
{
root.Network = rootConfig.Network;
}
foreach (var configExtension in config.Extensions)
{
var extension = new ExtensionConfiguration((string)configExtension["name"]);
foreach (var kvp in configExtension)
{
if (kvp.Key == "name")
{
continue;
}
extension.Data.Add(kvp.Key, kvp.Value);
}
root.Extensions.Add(extension);
}
var services = filter?.ServicesFilter != null?
config.Services.Where(filter.ServicesFilter).ToList() :
config.Services;
var sw = Stopwatch.StartNew();
// Project services will be restored and evaluated before resolving all other services.
// This batching will mitigate the performance cost of running MSBuild out of process.
var projectServices = services.Where(s => !string.IsNullOrEmpty(s.Project));
var projectMetadata = new Dictionary <string, string>();
using (var directory = TempDirectory.Create())
{
var projectPath = Path.Combine(directory.DirectoryPath, Path.GetRandomFileName() + ".proj");
var sb = new StringBuilder();
sb.AppendLine("<Project>");
sb.AppendLine(" <ItemGroup>");
foreach (var project in projectServices)
{
var expandedProject = Environment.ExpandEnvironmentVariables(project.Project !);
project.ProjectFullPath = Path.Combine(config.Source.DirectoryName !, expandedProject);
if (!File.Exists(project.ProjectFullPath))
{
throw new CommandException($"Failed to locate project: '{project.ProjectFullPath}'.");
}
sb.AppendLine($" <MicrosoftTye_ProjectServices " +
$"Include=\"{project.ProjectFullPath}\" " +
$"Name=\"{project.Name}\" " +
$"BuildProperties=\"" +
$"{(project.BuildProperties.Any() ? project.BuildProperties.Select(kvp => $"{kvp.Name}={kvp.Value}").Aggregate((a, b) => a + ";" + b) : string.Empty)}" +
$"{(string.IsNullOrEmpty(framework) ? string.Empty : $";TargetFramework={framework}")}" +
$"\" />");
}
sb.AppendLine(@" </ItemGroup>");
sb.AppendLine($@" <Target Name=""MicrosoftTye_EvaluateProjects"">");
sb.AppendLine($@" <MsBuild Projects=""@(MicrosoftTye_ProjectServices)"" "
+ $@"Properties=""%(BuildProperties);"
+ $@"MicrosoftTye_ProjectName=%(Name)"" "
+ $@"Targets=""MicrosoftTye_GetProjectMetadata"" BuildInParallel=""true"" />");
sb.AppendLine(" </Target>");
sb.AppendLine("</Project>");
File.WriteAllText(projectPath, sb.ToString());
output.WriteDebugLine("Restoring and evaluating projects");
var msbuildEvaluationResult = await ProcessUtil.RunAsync(
"dotnet",
$"build " +
$"\"{projectPath}\" " +
// CustomAfterMicrosoftCommonTargets is imported by non-crosstargeting (single TFM) projects
$"/p:CustomAfterMicrosoftCommonTargets={Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)!, "ProjectEvaluation.targets")} " +
// CustomAfterMicrosoftCommonCrossTargetingTargets is imported by crosstargeting (multi-TFM) projects
// This ensures projects properties are evaluated correctly. However, multi-TFM projects must specify
// a specific TFM to build/run/publish and will otherwise throw an exception.
$"/p:CustomAfterMicrosoftCommonCrossTargetingTargets={Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)!, "ProjectEvaluation.targets")} " +
$"/nologo",
throwOnError : false,
workingDirectory : directory.DirectoryPath);
// If the build fails, we're not really blocked from doing our work.
// For now we just log the output to debug. There are errors that occur during
// running these targets we don't really care as long as we get the data.
if (msbuildEvaluationResult.ExitCode != 0)
{
output.WriteDebugLine($"Evaluating project failed with exit code {msbuildEvaluationResult.ExitCode}:" +
$"{Environment.NewLine}Ouptut: {msbuildEvaluationResult.StandardOutput}" +
$"{Environment.NewLine}Error: {msbuildEvaluationResult.StandardError}");
}
var msbuildEvaluationOutput = msbuildEvaluationResult
.StandardOutput
.Split(Environment.NewLine);
foreach (var line in msbuildEvaluationOutput)
{
if (line.Trim().StartsWith("Microsoft.Tye metadata: "))
{
var values = line.Split(':', 3);
var projectName = values[1].Trim();
var metadataPath = values[2].Trim();
projectMetadata.Add(projectName, metadataPath);
output.WriteDebugLine($"Resolved metadata for service {projectName} at {metadataPath}");
}
}
output.WriteDebugLine($"Restore and project evaluation took: {sw.Elapsed.TotalMilliseconds}ms");
}
foreach (var configService in services)
{
ServiceBuilder service;
if (root.Services.Any(s => s.Name == configService.Name))
{
// Even though this service has already created a service, we still need
// to update dependency information
AddToRootServices(root, dependencies, configService.Name);
continue;
}
if (!string.IsNullOrEmpty(configService.Project))
{
var project = new DotnetProjectServiceBuilder(configService.Name !, new FileInfo(configService.ProjectFullPath));
service = project;
project.Build = configService.Build ?? true;
project.Args = configService.Args;
foreach (var buildProperty in configService.BuildProperties)
{
project.BuildProperties.Add(buildProperty.Name, buildProperty.Value);
}
project.Replicas = configService.Replicas ?? 1;
project.Liveness = configService.Liveness != null?GetProbeBuilder(configService.Liveness) : null;
project.Readiness = configService.Readiness != null?GetProbeBuilder(configService.Readiness) : null;
// We don't apply more container defaults here because we might need
// to prompt for the registry name.
project.ContainerInfo = new ContainerInfo()
{
UseMultiphaseDockerfile = false,
};
// If project evaluation is successful this should not happen, therefore an exception will be thrown.
if (!projectMetadata.ContainsKey(configService.Name))
{
throw new CommandException($"Evaluated project metadata file could not be found for service {configService.Name}");
}
ProjectReader.ReadProjectDetails(output, project, projectMetadata[configService.Name]);
if (framework != null && project.TargetFrameworks.Any())
{
// Only use the TargetFramework for the "--framework" if it's a multi-targeted project and an override is provided
project.BuildProperties["TargetFramework"] = framework;
}
// Do k8s by default.
project.ManifestInfo = new KubernetesManifestInfo();
}
else if (!string.IsNullOrEmpty(configService.Image))
{
var container = new ContainerServiceBuilder(configService.Name !, configService.Image !)
{
Args = configService.Args,
Replicas = configService.Replicas ?? 1
};
service = container;
container.Liveness = configService.Liveness != null?GetProbeBuilder(configService.Liveness) : null;
container.Readiness = configService.Readiness != null?GetProbeBuilder(configService.Readiness) : null;
}
else if (!string.IsNullOrEmpty(configService.DockerFile))
{
var dockerFile = new DockerFileServiceBuilder(configService.Name !, configService.Image !)
{
Args = configService.Args,
Build = configService.Build ?? true,
Replicas = configService.Replicas ?? 1,
DockerFile = Path.Combine(source.DirectoryName !, configService.DockerFile),
// Supplying an absolute path with trailing slashes fails for DockerFileContext when calling docker build, so trim trailing slash.
DockerFileContext = GetDockerFileContext(source, configService),
BuildArgs = configService.DockerFileArgs
};
service = dockerFile;
dockerFile.Liveness = configService.Liveness != null?GetProbeBuilder(configService.Liveness) : null;
dockerFile.Readiness = configService.Readiness != null?GetProbeBuilder(configService.Readiness) : null;
// We don't apply more container defaults here because we might need
// to prompt for the registry name.
dockerFile.ContainerInfo = new ContainerInfo()
{
UseMultiphaseDockerfile = false,
};
// Do k8s by default.
dockerFile.ManifestInfo = new KubernetesManifestInfo();
}
else if (!string.IsNullOrEmpty(configService.Executable))
{
var expandedExecutable = Environment.ExpandEnvironmentVariables(configService.Executable);
var workingDirectory = "";
// Special handling of .dlls as executables (it will be executed as dotnet {dll})
if (Path.GetExtension(expandedExecutable) == ".dll")
{
expandedExecutable = Path.GetFullPath(Path.Combine(config.Source.Directory !.FullName, expandedExecutable));
workingDirectory = Path.GetDirectoryName(expandedExecutable) !;
}
var executable = new ExecutableServiceBuilder(configService.Name !, expandedExecutable)
{
Args = configService.Args,
WorkingDirectory = configService.WorkingDirectory != null?
Path.GetFullPath(Path.Combine(config.Source.Directory !.FullName, Environment.ExpandEnvironmentVariables(configService.WorkingDirectory))) :
workingDirectory,
Replicas = configService.Replicas ?? 1
};
service = executable;
executable.Liveness = configService.Liveness != null?GetProbeBuilder(configService.Liveness) : null;
executable.Readiness = configService.Readiness != null?GetProbeBuilder(configService.Readiness) : null;
}
else if (!string.IsNullOrEmpty(configService.Include))
{
var expandedYaml = Environment.ExpandEnvironmentVariables(configService.Include);
var nestedConfig = GetNestedConfig(rootConfig, Path.Combine(config.Source.DirectoryName !, expandedYaml));
queue.Enqueue((nestedConfig, new HashSet <string>()));
AddToRootServices(root, dependencies, configService.Name);
continue;
}
else if (!string.IsNullOrEmpty(configService.Repository))
{
// clone to .tye folder
var path = configService.CloneDirectory ?? Path.Join(rootConfig.Source.DirectoryName, ".tye", "deps");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
var clonePath = Path.Combine(path, configService.Name);
if (!Directory.Exists(clonePath))
{
if (!await GitDetector.Instance.IsGitInstalled.Value)
{
throw new CommandException($"Cannot clone repository {configService.Repository} because git is not installed. Please install git if you'd like to use \"repository\" in tye.yaml.");
}
var result = await ProcessUtil.RunAsync("git", $"clone {configService.Repository} \"{clonePath}\"", workingDirectory : path, throwOnError : false);
if (result.ExitCode != 0)
{
throw new CommandException($"Failed to clone repository {configService.Repository} with exit code {result.ExitCode}.{Environment.NewLine}{result.StandardError}{result.StandardOutput}.");
}
}
if (!ConfigFileFinder.TryFindSupportedFile(clonePath, out var file, out var errorMessage))
{
throw new CommandException(errorMessage !);
}
// pick different service type based on what is in the repo.
var nestedConfig = GetNestedConfig(rootConfig, file);
queue.Enqueue((nestedConfig, new HashSet <string>()));
AddToRootServices(root, dependencies, configService.Name);
continue;
}
else if (!string.IsNullOrEmpty(configService.AzureFunction))
{
var azureFunctionDirectory = Path.Combine(config.Source.DirectoryName !, configService.AzureFunction);
var functionBuilder = new AzureFunctionServiceBuilder(
configService.Name,
azureFunctionDirectory)
{
Args = configService.Args,
Replicas = configService.Replicas ?? 1,
FuncExecutablePath = configService.FuncExecutable,
};
foreach (var proj in Directory.EnumerateFiles(azureFunctionDirectory))
{
var fileInfo = new FileInfo(proj);
if (fileInfo.Extension == ".csproj" || fileInfo.Extension == ".fsproj")
{
functionBuilder.ProjectFile = fileInfo.FullName;
break;
}
}
// TODO liveness?
service = functionBuilder;
}
else if (configService.External)
{
var external = new ExternalServiceBuilder(configService.Name);
service = external;
}
else
{
throw new CommandException("Unable to determine service type.");
}
// Add dependencies to ourself before adding ourself to avoid self reference
service.Dependencies.UnionWith(dependencies);
AddToRootServices(root, dependencies, service.Name);
root.Services.Add(service);
// If there are no bindings and we're in ASP.NET Core project then add an HTTP and HTTPS binding
if (configService.Bindings.Count == 0 &&
service is ProjectServiceBuilder project2 &&
project2.IsAspNet)
{
// HTTP is the default binding
service.Bindings.Add(new BindingBuilder()
{
Protocol = "http"
});
service.Bindings.Add(new BindingBuilder()
{
Name = "https", Protocol = "https"
});
}
public static (string, string) CreateTyeFileContent(FileInfo?path, bool force)
{
if (path is FileInfo && path.Exists && !force)
{
ThrowIfTyeFilePresent(path, "tye.yml");
ThrowIfTyeFilePresent(path, "tye.yaml");
}
if (force)
{
// Don't use existing tye.yaml if we are force creating it again.
// path prior is pointing to the tye.yaml file still, so refind another file that isn't the tye.yaml
var hasViableFileType = ConfigFileFinder.TryFindSupportedFile(path?.DirectoryName ?? ".",
out var filePath,
out var errorMessage,
new string[] { "*.csproj", "*.fsproj", "*.sln" });
if (!hasViableFileType)
{
throw new CommandException(errorMessage !);
}
path = new FileInfo(filePath !);
}
var template = @"
# tye application configuration file
# read all about it at https://github.com/dotnet/tye
#
# when you've given us a try, we'd love to know what you think:
# https://aka.ms/AA7q20u
#
# define global settings here
# name: exampleapp # application name
# registry: exampleuser # dockerhub username or container registry hostname
# define multiple services here
services:
- name: myservice
# project: app.csproj # msbuild project path (relative to this file)
# executable: app.exe # path to an executable (relative to this file)
# args: --arg1=3 # arguments to pass to the process
# replicas: 5 # number of times to launch the application
# env: # array of environment variables
# - name: key
# value: value
# bindings: # optional array of bindings (ports, connection strings)
# - port: 8080 # number port of the binding
".TrimStart();
// Output in the current directory unless an input file was provided, then
// output next to the input file.
var outputFilePath = "tye.yaml";
if (path is FileInfo && path.Exists)
{
var application = ConfigFactory.FromFile(path);
var serializer = YamlSerializer.CreateSerializer();
var extension = path.Extension.ToLowerInvariant();
var directory = path.Directory;
// Clear all bindings if any for solutions and project files
if (extension == ".sln" || extension == ".csproj" || extension == ".fsproj")
{
// If the input file is a project or solution then use that as the name
application.Extensions = null !;
application.Ingress = null !;
foreach (var service in application.Services)
{
service.Bindings = null !;
service.Configuration = null !;
service.Volumes = null !;
service.Project = service.Project !.Substring(directory !.FullName.Length).TrimStart('/');
}
// If the input file is a sln/project then place the config next to it
outputFilePath = Path.Combine(directory !.FullName, "tye.yaml");
}
else
{
// If the input file is a yaml, then replace it.
outputFilePath = path.FullName;
}
template = @"
# tye application configuration file
# read all about it at https://github.com/dotnet/tye
#
# when you've given us a try, we'd love to know what you think:
# https://aka.ms/AA7q20u
#
".TrimStart() + serializer.Serialize(application);
}
return(template, outputFilePath);
}
public static async Task <ApplicationBuilder> CreateAsync(OutputContext output, FileInfo source, ApplicationFactoryFilter?filter = null)
{
if (source is null)
{
throw new ArgumentNullException(nameof(source));
}
var queue = new Queue <(ConfigApplication, HashSet <string>)>();
var visited = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
var rootConfig = ConfigFactory.FromFile(source);
rootConfig.Validate();
var root = new ApplicationBuilder(source, rootConfig.Name !);
root.Namespace = rootConfig.Namespace;
queue.Enqueue((rootConfig, new HashSet <string>()));
while (queue.Count > 0)
{
var item = queue.Dequeue();
var config = item.Item1;
// dependencies represents a set of all dependencies
var dependencies = item.Item2;
if (!visited.Add(config.Source.FullName))
{
continue;
}
if (config == rootConfig && !string.IsNullOrEmpty(config.Registry))
{
root.Registry = new ContainerRegistry(config.Registry);
}
if (config == rootConfig)
{
root.Network = rootConfig.Network;
}
foreach (var configExtension in config.Extensions)
{
var extension = new ExtensionConfiguration((string)configExtension["name"]);
foreach (var kvp in configExtension)
{
if (kvp.Key == "name")
{
continue;
}
extension.Data.Add(kvp.Key, kvp.Value);
}
root.Extensions.Add(extension);
}
var services = filter?.ServicesFilter != null?
config.Services.Where(filter.ServicesFilter).ToList() :
config.Services;
foreach (var configService in services)
{
ServiceBuilder service;
if (root.Services.Any(s => s.Name == configService.Name))
{
// Even though this service has already created a service, we still need
// to update dependency information
AddToRootServices(root, dependencies, configService.Name);
continue;
}
if (!string.IsNullOrEmpty(configService.Project))
{
var expandedProject = Environment.ExpandEnvironmentVariables(configService.Project);
var projectFile = new FileInfo(Path.Combine(config.Source.DirectoryName, expandedProject));
var project = new DotnetProjectServiceBuilder(configService.Name !, projectFile);
service = project;
project.Build = configService.Build ?? true;
project.Args = configService.Args;
foreach (var buildProperty in configService.BuildProperties)
{
project.BuildProperties.Add(buildProperty.Name, buildProperty.Value);
}
project.Replicas = configService.Replicas ?? 1;
project.Liveness = configService.Liveness != null?GetProbeBuilder(configService.Liveness) : null;
project.Readiness = configService.Readiness != null?GetProbeBuilder(configService.Readiness) : null;
// We don't apply more container defaults here because we might need
// to prompt for the registry name.
project.ContainerInfo = new ContainerInfo()
{
UseMultiphaseDockerfile = false,
};
await ProjectReader.ReadProjectDetailsAsync(output, project);
// Do k8s by default.
project.ManifestInfo = new KubernetesManifestInfo();
}
else if (!string.IsNullOrEmpty(configService.Image))
{
var container = new ContainerServiceBuilder(configService.Name !, configService.Image !)
{
Args = configService.Args,
Replicas = configService.Replicas ?? 1
};
service = container;
container.Liveness = configService.Liveness != null?GetProbeBuilder(configService.Liveness) : null;
container.Readiness = configService.Readiness != null?GetProbeBuilder(configService.Readiness) : null;
}
else if (!string.IsNullOrEmpty(configService.DockerFile))
{
var dockerFile = new DockerFileServiceBuilder(configService.Name !, configService.Image !)
{
Args = configService.Args,
Build = configService.Build ?? true,
Replicas = configService.Replicas ?? 1,
DockerFile = Path.Combine(source.DirectoryName, configService.DockerFile),
// Supplying an absolute path with trailing slashes fails for DockerFileContext when calling docker build, so trim trailing slash.
DockerFileContext = GetDockerFileContext(source, configService),
BuildArgs = configService.DockerFileArgs
};
service = dockerFile;
dockerFile.Liveness = configService.Liveness != null?GetProbeBuilder(configService.Liveness) : null;
dockerFile.Readiness = configService.Readiness != null?GetProbeBuilder(configService.Readiness) : null;
// We don't apply more container defaults here because we might need
// to prompt for the registry name.
dockerFile.ContainerInfo = new ContainerInfo()
{
UseMultiphaseDockerfile = false,
};
// Do k8s by default.
dockerFile.ManifestInfo = new KubernetesManifestInfo();
}
else if (!string.IsNullOrEmpty(configService.Executable))
{
var expandedExecutable = Environment.ExpandEnvironmentVariables(configService.Executable);
var workingDirectory = "";
// Special handling of .dlls as executables (it will be executed as dotnet {dll})
if (Path.GetExtension(expandedExecutable) == ".dll")
{
expandedExecutable = Path.GetFullPath(Path.Combine(config.Source.Directory.FullName, expandedExecutable));
workingDirectory = Path.GetDirectoryName(expandedExecutable) !;
}
var executable = new ExecutableServiceBuilder(configService.Name !, expandedExecutable)
{
Args = configService.Args,
WorkingDirectory = configService.WorkingDirectory != null?
Path.GetFullPath(Path.Combine(config.Source.Directory.FullName, Environment.ExpandEnvironmentVariables(configService.WorkingDirectory))) :
workingDirectory,
Replicas = configService.Replicas ?? 1
};
service = executable;
executable.Liveness = configService.Liveness != null?GetProbeBuilder(configService.Liveness) : null;
executable.Readiness = configService.Readiness != null?GetProbeBuilder(configService.Readiness) : null;
}
else if (!string.IsNullOrEmpty(configService.Include))
{
var expandedYaml = Environment.ExpandEnvironmentVariables(configService.Include);
var nestedConfig = GetNestedConfig(rootConfig, Path.Combine(config.Source.DirectoryName, expandedYaml));
queue.Enqueue((nestedConfig, new HashSet <string>()));
AddToRootServices(root, dependencies, configService.Name);
continue;
}
else if (!string.IsNullOrEmpty(configService.Repository))
{
// clone to .tye folder
var path = Path.Join(rootConfig.Source.DirectoryName, ".tye", "deps");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
var clonePath = Path.Combine(path, configService.Name);
if (!Directory.Exists(clonePath))
{
if (!await GitDetector.Instance.IsGitInstalled.Value)
{
throw new CommandException($"Cannot clone repository {configService.Repository} because git is not installed. Please install git if you'd like to use \"repository\" in tye.yaml.");
}
var result = await ProcessUtil.RunAsync("git", $"clone {configService.Repository} {clonePath}", workingDirectory : path, throwOnError : false);
if (result.ExitCode != 0)
{
throw new CommandException($"Failed to clone repository {configService.Repository} with exit code {result.ExitCode}.{Environment.NewLine}{result.StandardError}{result.StandardOutput}.");
}
}
if (!ConfigFileFinder.TryFindSupportedFile(clonePath, out var file, out var errorMessage))
{
throw new CommandException(errorMessage !);
}
// pick different service type based on what is in the repo.
var nestedConfig = GetNestedConfig(rootConfig, file);
queue.Enqueue((nestedConfig, new HashSet <string>()));
AddToRootServices(root, dependencies, configService.Name);
continue;
}
else if (configService.External)
{
var external = new ExternalServiceBuilder(configService.Name !);
service = external;
}
else
{
throw new CommandException("Unable to determine service type.");
}
// Add dependencies to ourself before adding ourself to avoid self reference
service.Dependencies.UnionWith(dependencies);
AddToRootServices(root, dependencies, service.Name);
root.Services.Add(service);
// If there are no bindings and we're in ASP.NET Core project then add an HTTP and HTTPS binding
if (configService.Bindings.Count == 0 &&
service is ProjectServiceBuilder project2 &&
project2.IsAspNet)
{
// HTTP is the default binding
service.Bindings.Add(new BindingBuilder()
{
Protocol = "http"
});
service.Bindings.Add(new BindingBuilder()
{
Name = "https", Protocol = "https"
});
}