cs-codex-dist-tests/KubernetesWorkflow/StartupWorkflow.cs

202 lines
6.7 KiB
C#
Raw Normal View History

2023-04-25 09:31:15 +00:00
using Logging;
using Utils;
namespace KubernetesWorkflow
2023-04-12 11:53:55 +00:00
{
public class StartupWorkflow
{
2023-04-25 09:31:15 +00:00
private readonly BaseLog log;
private readonly WorkflowNumberSource numberSource;
private readonly K8sCluster cluster;
private readonly KnownK8sPods knownK8SPods;
2023-05-03 12:18:37 +00:00
private readonly string testNamespace;
2023-08-10 09:25:22 +00:00
private readonly PodLabels podLabels;
2023-04-12 11:53:55 +00:00
private readonly RecipeComponentFactory componentFactory = new RecipeComponentFactory();
2023-08-10 09:25:22 +00:00
internal StartupWorkflow(BaseLog log, WorkflowNumberSource numberSource, K8sCluster cluster, KnownK8sPods knownK8SPods, string testNamespace, PodLabels podLabels)
2023-04-12 11:53:55 +00:00
{
2023-04-25 09:31:15 +00:00
this.log = log;
this.numberSource = numberSource;
this.cluster = cluster;
this.knownK8SPods = knownK8SPods;
2023-05-03 12:18:37 +00:00
this.testNamespace = testNamespace;
2023-08-10 09:25:22 +00:00
this.podLabels = podLabels;
2023-04-12 11:53:55 +00:00
}
public RunningContainers Start(int numberOfContainers, Location location, ContainerRecipeFactory recipeFactory, StartupConfig startupConfig)
2023-04-12 11:53:55 +00:00
{
2023-08-10 09:47:34 +00:00
var pl = podLabels.GetLabelsForAppName(recipeFactory.AppName);
2023-08-07 13:51:44 +00:00
return K8s(controller =>
{
var recipes = CreateRecipes(numberOfContainers, recipeFactory, startupConfig);
var runningPod = controller.BringOnline(recipes, location);
2023-04-12 11:53:55 +00:00
return new RunningContainers(startupConfig, runningPod, CreateContainers(runningPod, recipes, startupConfig));
2023-08-10 09:47:34 +00:00
}, pl);
}
2023-04-12 11:53:55 +00:00
2023-08-15 09:01:18 +00:00
public CrashWatcher CreateCrashWatcher(RunningContainer container)
2023-08-14 13:10:36 +00:00
{
2023-08-15 09:01:18 +00:00
return K8s(controller => controller.CreateCrashWatcher(container));
2023-08-14 13:10:36 +00:00
}
2023-04-13 09:07:36 +00:00
public void Stop(RunningContainers runningContainers)
{
K8s(controller =>
{
controller.Stop(runningContainers.RunningPod);
});
}
2023-04-13 09:30:19 +00:00
public void DownloadContainerLog(RunningContainer container, ILogHandler logHandler)
{
K8s(controller =>
{
controller.DownloadPodLog(container.Pod, container.Recipe, logHandler);
});
}
2023-04-14 07:54:07 +00:00
public string ExecuteCommand(RunningContainer container, string command, params string[] args)
{
return K8s(controller =>
{
return controller.ExecuteCommand(container.Pod, container.Recipe.Name, command, args);
});
}
public void DeleteAllResources()
{
K8s(controller =>
{
controller.DeleteAllResources();
});
2023-04-12 11:53:55 +00:00
}
2023-05-03 12:18:37 +00:00
public void DeleteTestResources()
{
K8s(controller =>
{
controller.DeleteTestNamespace();
});
}
private RunningContainer[] CreateContainers(RunningPod runningPod, ContainerRecipe[] recipes, StartupConfig startupConfig)
2023-04-12 11:53:55 +00:00
{
2023-04-25 09:31:15 +00:00
log.Debug();
return recipes.Select(r =>
{
var servicePorts = runningPod.GetServicePortsForContainerRecipe(r);
log.Debug($"{r} -> service ports: {string.Join(",", servicePorts.Select(p => p.Number))}");
var name = GetContainerName(r, startupConfig);
return new RunningContainer(runningPod, r, servicePorts, name,
GetContainerExternalAddress(runningPod, servicePorts),
GetContainerInternalAddress(r));
}).ToArray();
2023-04-12 11:53:55 +00:00
}
private string GetContainerName(ContainerRecipe recipe, StartupConfig startupConfig)
{
if (startupConfig == null) return "";
if (!string.IsNullOrEmpty(startupConfig.NameOverride))
{
return $"<{startupConfig.NameOverride}{recipe.Number}>";
}
else
{
return $"<{recipe.Name}>";
}
}
private Address GetContainerExternalAddress(RunningPod pod, Port[] servicePorts)
{
return new Address(
pod.Cluster.HostAddress,
GetServicePort(servicePorts));
}
private Address GetContainerInternalAddress(ContainerRecipe recipe)
{
var serviceName = "service-" + numberSource.WorkflowNumber;
var namespaceName = cluster.Configuration.K8sNamespacePrefix + testNamespace;
var port = GetInternalPort(recipe);
return new Address(
$"http://{serviceName}.{namespaceName}.svc.cluster.local",
port);
}
private static int GetServicePort(Port[] servicePorts)
{
if (servicePorts.Any()) return servicePorts.First().Number;
return 0;
}
private static int GetInternalPort(ContainerRecipe recipe)
{
if (recipe.ExposedPorts.Any()) return recipe.ExposedPorts.First().Number;
return 0;
}
2023-04-12 11:53:55 +00:00
private ContainerRecipe[] CreateRecipes(int numberOfContainers, ContainerRecipeFactory recipeFactory, StartupConfig startupConfig)
{
2023-04-25 09:31:15 +00:00
log.Debug();
2023-04-12 11:53:55 +00:00
var result = new List<ContainerRecipe>();
for (var i = 0; i < numberOfContainers; i++)
{
result.Add(recipeFactory.CreateRecipe(i, numberSource.GetContainerNumber(), componentFactory, startupConfig));
2023-04-12 11:53:55 +00:00
}
return result.ToArray();
}
private void K8s(Action<K8sController> action)
{
2023-08-10 09:25:22 +00:00
var controller = new K8sController(log, cluster, knownK8SPods, numberSource, testNamespace, podLabels);
action(controller);
controller.Dispose();
}
private T K8s<T>(Func<K8sController, T> action)
2023-08-07 13:51:44 +00:00
{
var controller = new K8sController(log, cluster, knownK8SPods, numberSource, testNamespace, podLabels);
var result = action(controller);
controller.Dispose();
return result;
}
2023-08-10 09:47:34 +00:00
private T K8s<T>(Func<K8sController, T> action, PodLabels labels)
{
var controller = new K8sController(log, cluster, knownK8SPods, numberSource, testNamespace, labels);
var result = action(controller);
controller.Dispose();
return result;
}
2023-04-13 09:30:19 +00:00
}
2023-04-13 09:30:19 +00:00
public interface ILogHandler
{
void Log(Stream log);
2023-04-12 11:53:55 +00:00
}
public abstract class LogHandler : ILogHandler
{
public void Log(Stream log)
{
using var reader = new StreamReader(log);
var line = reader.ReadLine();
while (line != null)
{
ProcessLine(line);
line = reader.ReadLine();
}
}
protected abstract void ProcessLine(string line);
}
2023-04-12 11:53:55 +00:00
}