public void AppWithAttributeHasCorrectDescription()
{
var app = new AppWithAttribute();
var analyzer = new AppAnalyzer(app);
Assert.Equal("test-app", analyzer.Name);
Assert.Equal(new Version(1, 1, 1, 1), analyzer.Version);
Assert.Equal("tester", analyzer.Author);
Assert.Equal("test description", analyzer.Description);
Assert.Equal(2, analyzer.Parameters.Count());
Assert.NotNull(analyzer.GetParameter("mandatory"));
Assert.True(analyzer.GetParameter("mandatory").Mandatory);
Assert.False(analyzer.GetParameter("mandatory").IsSet);
Assert.NotNull(analyzer.GetParameter("non-mandatory"));
Assert.False(analyzer.GetParameter("non-mandatory").Mandatory);
analyzer.GetParameter("mandatory").Set("test value");
Assert.True(analyzer.GetParameter("mandatory").IsSet);
Assert.Equal("test value", app.MandatoryParam);
analyzer.GetParameter("non-mandatory").Set("42");
Assert.Equal(42, app.NonMandatoryParam);
Assert.Single(analyzer.Dependencies);
Assert.NotNull(analyzer.GetDependency("Dep"));
}
public async Task <IActionResult> Configure(string fullTypeName)
{
var app = (IApp)Activator.CreateInstance(ResolveAppType(fullTypeName));
var analyzer = new AppAnalyzer(app);
var model = new ConfigureAppModel();
await model.InitializeAsync(analyzer);
return(View(model));
}
public void AppWithoutAttributeHasCorrectDescription()
{
var analyzer = new AppAnalyzer(new AppWithoutAttribute());
Assert.Equal("AppWithoutAttribute", analyzer.Name);
Assert.Equal(new Version(0, 0, 0, 0), analyzer.Version);
Assert.Null(analyzer.Author);
Assert.Null(analyzer.Description);
}
internal static void Select(string name)
{
if (_registry.TryGetValue(name, out var app))
{
SelectedApp = app;
}
else
{
throw new InvalidOperationException($"app \"{name}\" not found");
}
}
public void ApplyTo(AppAnalyzer app)
{
var settable = app.Parameters.ToList();
for (var i = 0; i < Parameters.Count; i++)
{
settable[i].Set(Parameters[i].Value);
}
var deps = app.Dependencies.ToList();
for (var i = 0; i < Dependencies.Count; i++)
{
Dependencies[i].ApplyTo(deps[i]);
}
}
IEnumerable <(string prefix, Parameter param)> FlattenParameters(AppAnalyzer app, string prefix)
{
foreach (var p in app.Parameters)
{
yield return(prefix, p);
}
foreach (var dep in app.Dependencies)
{
prefix = prefix.Length == 0 ? dep.Name + "." : $"{prefix}.{dep.Name}.";
foreach (var p in FlattenParameters(dep, prefix))
{
yield return(p);
}
}
}
public async Task <IActionResult> Deploy(string fullTypeName, ConfigureAppModel model)
{
var app = (IApp)Activator.CreateInstance(ResolveAppType(fullTypeName));
var analyzer = new AppAnalyzer(app);
model.ApplyTo(analyzer);
var appBuilder = new AppBuilder();
await analyzer.Build(appBuilder);
var restoredModel = new ConfigureAppModel();
await restoredModel.InitializeAsync(analyzer);
restoredModel.RuntimeSettings.Clear();
restoredModel.RuntimeSettings.AddRange(model.RuntimeSettings);
// generate parameters
var parametersYaml = GenerateParametersYaml(restoredModel);
var runtimeSettingsYaml = GenerateRuntimeSettingsYaml(restoredModel);
var svcFile = Path.GetTempFileName();
var paramsFile = Path.GetTempFileName();
var runtimeFile = Path.GetTempFileName();
try {
using (var svcStream = System.IO.File.Create(svcFile)){
appBuilder.BuiltApp.WriteTo(svcStream);
await svcStream.FlushAsync();
}
await System.IO.File.WriteAllTextAsync(paramsFile, parametersYaml, Encoding.UTF8);
await System.IO.File.WriteAllTextAsync(runtimeFile, runtimeSettingsYaml, Encoding.UTF8);
await _backend.RunAsync(model.DeploymentName, svcFile, paramsFile, runtimeFile);
} finally {
System.IO.File.Delete(svcFile);
System.IO.File.Delete(paramsFile);
System.IO.File.Delete(runtimeFile);
}
return(RedirectToAction("List", "AppLibs"));
}
private static void PrintAppParamsYaml(string prefix, AppAnalyzer app)
{
foreach (var p in app.Parameters)
{
if (!string.IsNullOrEmpty(p.Description))
{
Console.Write($"{prefix}# {p.Description}\n");
}
Console.Write($"{prefix}{p.Name}: ");
if (!string.IsNullOrEmpty(p.Get()))
{
Console.Write($"# default: {p.Get()}");
}
Console.Write("\n");
}
foreach (var dep in app.Dependencies)
{
Console.Write($"{prefix}{dep.Name}:\n");
PrintAppParamsYaml(prefix + " ", dep);
}
}
public async Task InitializeAsync(AppAnalyzer app)
{
Name = app.Name;
AppType = app.App.GetType();
foreach (var p in app.Parameters)
{
Parameters.Add(new Parameter {
Description = p.Description,
Mandatory = p.Mandatory,
Name = p.Name,
Type = p.ParameterType,
Value = p.Get()
});
}
foreach (var dep in app.Dependencies)
{
var m = new ConfigureAppModel();
await m.InitializeAsync(dep);
Dependencies.Add(m);
}
var appBuilder = new AppBuilder();
await app.Build(appBuilder);
foreach (var svc in appBuilder.BuiltApp.Services)
{
RuntimeSettings.Add(
new ServiceRuntimeSettings {
Name = svc.Name,
Scalable = svc.ScalabilityModel == ScalabilityModel.Scalable,
Scale = 1,
});
}
}
