public static void ReadAzureFunctionProjectDetails(OutputContext output, AzureFunctionServiceBuilder project, string metadataFile)
{
if (output is null)
{
throw new ArgumentNullException(nameof(output));
}
if (project is null)
{
throw new ArgumentNullException(nameof(project));
}
if (metadataFile is null)
{
throw new ArgumentNullException(nameof(metadataFile));
}
EvaluateAzureFunctionProject(output, project, metadataFile);
}
private static void EvaluateAzureFunctionProject(OutputContext output, AzureFunctionServiceBuilder project, string metadataFile)
{
var sw = Stopwatch.StartNew();
var metadata = new Dictionary <string, string>();
var metadataKVPs = File.ReadLines(metadataFile).Select(l => l.Split(new[] { ':' }, 2));
foreach (var metadataKVP in metadataKVPs)
{
if (!string.IsNullOrEmpty(metadataKVP[1]))
{
metadata.Add(metadataKVP[0], metadataKVP[1].Trim());
}
}
project.AzureFunctionsVersion = GetMetadataValueOrNull("AzureFunctionsVersion");
output.WriteDebugLine($"AzureFunctionsVersion={project.AzureFunctionsVersion}");
output.WriteDebugLine($"Evaluation Took: {sw.Elapsed.TotalMilliseconds}ms");
string?GetMetadataValueOrNull(string key) => metadata !.TryGetValue(key, out var value) ? value : null;
}
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 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 = 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"
});
}
