public void LoadKubeConfigFileInfo()
{
var filePath = "assets/kubeconfig.yml";
var txt = File.ReadAllText(filePath);
var expectedCfg = Yaml.LoadFromString <K8SConfiguration>(txt);
var fileInfo = new FileInfo(filePath);
var cfg = KubernetesClientConfiguration.LoadKubeConfig(fileInfo);
Assert.NotNull(cfg);
AssertConfigEqual(expectedCfg, cfg);
}
public void LoadFromString()
{
var content = @"apiVersion: v1
kind: Pod
metadata:
name: foo
";
var obj = Yaml.LoadFromString <V1Pod>(content);
Assert.Equal("foo", obj.Metadata.Name);
}
public void LoadFromStringWithAdditionalProperties()
{
var content = @"apiVersion: v1
kind: Pod
metadata:
name: foo
youDontKnow: Me
";
var obj = Yaml.LoadFromString <V1Pod>(content);
Assert.Equal("foo", obj.Metadata.Name);
}
/// <summary>
/// Constructor of IIoTK8SClient.
/// </summary>
/// <param name="kubeConfigContent"></param>
public IIoTK8SClient(string kubeConfigContent)
{
if (string.IsNullOrEmpty(kubeConfigContent))
{
throw new ArgumentNullException(nameof(kubeConfigContent));
}
_k8sConfiguration = Yaml.LoadFromString <K8SConfiguration>(kubeConfigContent);
_k8sClientConfiguration = KubernetesClientConfiguration
.BuildConfigFromConfigObject(_k8sConfiguration);
_k8sClient = new Kubernetes(_k8sClientConfiguration);
}
public static V1Deployment GetSpec(string name, string appName, string image, string appDir, string volumeName, string azShareName)
{
var obj = new RunTimeDeployment
{
Name = name,
AppName = appName,
Image = image,
AppDir = appDir,
VolumeName = volumeName,
AzureFileShareName = azShareName,
};
return(Yaml.LoadFromString <V1Deployment>(obj.TransformText()));
}
public void LoadIntOrString()
{
var content = @"apiVersion: v1
kind: Service
spec:
ports:
- port: 3000
targetPort: 3000
";
var obj = Yaml.LoadFromString <V1Service>(content);
Assert.Equal(3000, obj.Spec.Ports[0].Port);
Assert.Equal(3000, (int)obj.Spec.Ports[0].TargetPort);
}
public void LoadSecret()
{
var kManifest = @"
apiVersion: v1
kind: Secret
metadata:
name: test-secret
data:
username: bXktYXBw
password: Mzk1MjgkdmRnN0pi
";
var result = Yaml.LoadFromString <V1Secret>(kManifest);
Assert.Equal("bXktYXBw", Encoding.UTF8.GetString(result.Data["username"]));
Assert.Equal("Mzk1MjgkdmRnN0pi", Encoding.UTF8.GetString(result.Data["password"]));
}
public void LoadKubeConfigStream()
{
var filePath = "assets/kubeconfig.yml";
var txt = File.ReadAllText(filePath);
var expectedCfg = Yaml.LoadFromString <K8SConfiguration>(txt);
var fileInfo = new FileInfo(filePath);
K8SConfiguration cfg;
using (var stream = fileInfo.OpenRead())
{
cfg = KubernetesClientConfiguration.LoadKubeConfig(stream);
}
Assert.NotNull(cfg);
AssertConfigEqual(expectedCfg, cfg);
}
public async Task <V1ConfigMap> CreateV1ConfigMapAsync(
string v1ConfigMapContent,
string namespaceParameter = null,
IDictionary <string, string> data = null,
CancellationToken cancellationToken = default
)
{
if (string.IsNullOrEmpty(v1ConfigMapContent))
{
throw new ArgumentNullException(nameof(v1ConfigMapContent));
}
try {
Log.Verbose("Loading k8s ConfigMap definition ...");
var v1ConfigMapDefinition = Yaml.LoadFromString <V1ConfigMap>(v1ConfigMapContent);
if (null != data)
{
foreach (var dataKVP in data)
{
v1ConfigMapDefinition.Data[dataKVP.Key] = dataKVP.Value;
}
}
if (null != namespaceParameter)
{
v1ConfigMapDefinition.Metadata.NamespaceProperty = namespaceParameter;
}
Log.Verbose($"Creating k8s ConfigMap: {v1ConfigMapDefinition.Metadata.Name} ...");
var v1ConfigMap = await _k8sClient
.CreateNamespacedConfigMapAsync(
v1ConfigMapDefinition,
v1ConfigMapDefinition.Metadata.NamespaceProperty,
cancellationToken : cancellationToken
);
Log.Verbose($"Created k8s ConfigMap: {v1ConfigMap.Metadata.Name}");
return(v1ConfigMap);
}
catch (Exception ex) {
Log.Error(ex, $"Failed to create k8s ConfigMap");
throw;
}
}
public async Task <V1Secret> CreateV1SecretAsync(
string v1SecretContent,
string namespaceParameter = null,
IDictionary <string, string> data = null,
CancellationToken cancellationToken = default
)
{
if (string.IsNullOrWhiteSpace(v1SecretContent))
{
throw new ArgumentNullException(nameof(v1SecretContent));
}
try {
Log.Verbose("Loading k8s Secret definition ...");
var v1SecretDefinition = Yaml.LoadFromString <V1Secret>(v1SecretContent);
if (null != data)
{
foreach (var dataKVP in data)
{
v1SecretDefinition.Data[dataKVP.Key] = Encoding.UTF8.GetBytes(dataKVP.Value);
}
}
if (null != namespaceParameter)
{
v1SecretDefinition.Metadata.NamespaceProperty = namespaceParameter;
}
Log.Verbose($"Creating k8s Secret: {v1SecretDefinition.Metadata.Name} ...");
var v1Secret = await _k8sClient
.CreateNamespacedSecretAsync(
v1SecretDefinition,
v1SecretDefinition.Metadata.NamespaceProperty,
cancellationToken : cancellationToken
);
Log.Verbose($"Created k8s Secret: {v1Secret.Metadata.Name}");
return(v1Secret);
}
catch (Exception ex) {
Log.Error(ex, $"Failed to create k8s Secret");
throw;
}
}
public async Task <V1Secret> CreateNGINXDefaultSSLCertificateSecretAsync(
string certPem,
string privateKeyPem
)
{
try {
const string tlsCrt = "tls.crt";
const string tlsKey = "tls.key";
var certPemBytes = Encoding.UTF8.GetBytes(certPem);
var privateKeyPemBytes = Encoding.UTF8.GetBytes(privateKeyPem);
Log.Verbose("Loading k8s Secret definition ...");
var v1SecretDefinition = Yaml
.LoadFromString <k8s.Models.V1Secret>(
Resources.IIoTK8SResources._20_web_app_secret
);
v1SecretDefinition.Data[tlsCrt] = certPemBytes;
v1SecretDefinition.Data[tlsKey] = privateKeyPemBytes;
if (null != _iiotNamespace)
{
v1SecretDefinition.Metadata.NamespaceProperty = _iiotNamespace;
}
Log.Verbose($"Creating k8s Secret: {v1SecretDefinition.Metadata.Name} ...");
var v1Secret = await _k8sClient
.CreateNamespacedSecretAsync(
v1SecretDefinition,
v1SecretDefinition.Metadata.NamespaceProperty
);
Log.Verbose($"Created k8s Secret: {v1Secret.Metadata.Name}");
return(v1Secret);
}
catch (Exception ex) {
Log.Error(ex, $"Failed to create k8s Secret");
throw;
}
}
public async Task <Extensionsv1beta1Ingress> CreateExtensionsv1beta1IngressAsync(
string extensionsv1beta1IngressContent,
string namespaceParameter = null,
CancellationToken cancellationToken = default
)
{
if (string.IsNullOrEmpty(extensionsv1beta1IngressContent))
{
throw new ArgumentNullException(nameof(extensionsv1beta1IngressContent));
}
try {
Log.Verbose("Loading k8s Ingress definition ...");
var extensionsv1beta1IngressDefinition = Yaml
.LoadFromString <Extensionsv1beta1Ingress>(
extensionsv1beta1IngressContent
);
if (null != namespaceParameter)
{
extensionsv1beta1IngressDefinition.Metadata.NamespaceProperty = namespaceParameter;
}
Log.Verbose($"Creating k8s Ingress: " +
$"{extensionsv1beta1IngressDefinition.Metadata.Name} ...");
var extensionsv1beta1Ingress = await _k8sClient
.CreateNamespacedIngressAsync(
extensionsv1beta1IngressDefinition,
extensionsv1beta1IngressDefinition.Metadata.NamespaceProperty,
cancellationToken : cancellationToken
);
Log.Verbose($"Created k8s Ingress: {extensionsv1beta1Ingress.Metadata.Name}");
return(extensionsv1beta1Ingress);
}
catch (Exception ex) {
Log.Error(ex, $"Failed to create k8s Ingress");
throw;
}
}
private async Task <V1Deployment> CreateV1DeploymentAsync(
string v1DeploymentContent,
string namespaceParameter = null,
CancellationToken cancellationToken = default
)
{
if (string.IsNullOrEmpty(v1DeploymentContent))
{
throw new ArgumentNullException(nameof(v1DeploymentContent));
}
try {
Log.Verbose("Loading k8s Deployment definition ...");
var v1DeploymentDefinition = Yaml
.LoadFromString <V1Deployment>(
v1DeploymentContent
);
if (null != namespaceParameter)
{
v1DeploymentDefinition.Metadata.NamespaceProperty = namespaceParameter;
}
Log.Verbose($"Creating k8s Deployment: {v1DeploymentDefinition.Metadata.Name} ...");
var v1Deployment = await _k8sClient
.CreateNamespacedDeploymentAsync(
v1DeploymentDefinition,
v1DeploymentDefinition.Metadata.NamespaceProperty,
cancellationToken : cancellationToken
);
Log.Verbose($"Created k8s Deployment: {v1Deployment.Metadata.Name}");
return(v1Deployment);
}
catch (Exception ex) {
Log.Error(ex, $"Failed to create k8s Deployment");
throw;
}
}
/// <summary>
/// Create a custom ClusterIssuer object.
/// </summary>
/// <param name="clusterIssuerContent"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <V1Alpha2ClusterIssuer> CreateV1Alpha2ClusterIssuerAsync(
string clusterIssuerContent,
CancellationToken cancellationToken = default
)
{
if (string.IsNullOrWhiteSpace(clusterIssuerContent))
{
throw new ArgumentNullException(nameof(clusterIssuerContent));
}
Log.Verbose("Loading k8s ClusterIssuer definition ...");
var clusterIssuerDefinition = Yaml
.LoadFromString <V1Alpha2ClusterIssuer>(
clusterIssuerContent
);
Log.Verbose($"Creating k8s ClusterIssuer: {clusterIssuerDefinition.Metadata.Name} ...");
var clusterIssuerObject = await _k8sClient
.CreateClusterCustomObjectAsync(
clusterIssuerDefinition,
V1Alpha2ClusterIssuer.KubeGroup,
V1Alpha2ClusterIssuer.KubeApiVersion,
V1Alpha2ClusterIssuer.KubeKindPlural,
cancellationToken : cancellationToken
);
// Convert returned object back to V1Alpha2ClusterIssuer.
if (!(clusterIssuerObject is JObject))
{
throw new Exception($"Returned object is of unexpected type: {clusterIssuerObject.GetType()}");
}
// Note: Here we will loose extra fields that are not present in our V1Alpha2ClusterIssuer.
var clusterIssuerJObject = (JObject)clusterIssuerObject;
var clusterIssuer = clusterIssuerJObject.ToObject <V1Alpha2ClusterIssuer>();
Log.Verbose($"Created k8s ClusterIssuer: {clusterIssuerDefinition.Metadata.Name} ...");
return(clusterIssuer);
}
public async Task <V1Secret> CreateIIoTEnvSecretAsync(
IDictionary <string, string> env
)
{
try {
Log.Verbose("Loading k8s Secret definition ...");
var iiotSecretDefinition = Yaml
.LoadFromString <V1Secret>(
Resources.IIoTK8SResources._01_industrial_iot_env_secret
);
foreach (var envKVP in env)
{
iiotSecretDefinition.Data[envKVP.Key] = Encoding.UTF8.GetBytes(envKVP.Value);
}
if (null != _iiotNamespace)
{
iiotSecretDefinition.Metadata.NamespaceProperty = _iiotNamespace;
}
Log.Verbose($"Creating k8s Secret: {iiotSecretDefinition.Metadata.Name} ...");
var iiotSecret = await _k8sClient
.CreateNamespacedSecretAsync(
iiotSecretDefinition,
iiotSecretDefinition.Metadata.NamespaceProperty
);
Log.Verbose($"Created k8s Secret: {iiotSecret.Metadata.Name}");
return(iiotSecret);
}
catch (Exception ex) {
Log.Error(ex, $"Failed to create k8s Secret");
throw;
}
}
public void CpuRequestAndLimitFromString()
{
// Taken from https://raw.githubusercontent.com/kubernetes/website/master/docs/tasks/configure-pod-container/cpu-request-limit.yaml, although
// the 'namespace' property on 'metadata' was removed since it was rejected by the C# client.
var content = @"apiVersion: v1
kind: Pod
metadata:
name: cpu-demo
spec:
containers:
- name: cpu-demo-ctr
image: vish/stress
resources:
limits:
cpu: ""1""
requests:
cpu: ""0.5""
args:
- -cpus
- ""2""";
var obj = Yaml.LoadFromString <V1Pod>(content);
Assert.NotNull(obj?.Spec?.Containers);
var container = Assert.Single(obj.Spec.Containers);
Assert.NotNull(container.Resources);
Assert.NotNull(container.Resources.Limits);
Assert.NotNull(container.Resources.Requests);
var cpuLimit = Assert.Single(container.Resources.Limits);
var cpuRequest = Assert.Single(container.Resources.Requests);
Assert.Equal("cpu", cpuLimit.Key);
Assert.Equal("1", cpuLimit.Value.ToString());
Assert.Equal("cpu", cpuRequest.Key);
Assert.Equal("500m", cpuRequest.Value.ToString());
}
public async Task <V1RoleBinding> CreateV1RoleBindingAsync(
string v1RoleBindingContent,
string namespaceParameter = null,
CancellationToken cancellationToken = default
)
{
if (string.IsNullOrWhiteSpace(v1RoleBindingContent))
{
throw new ArgumentNullException(nameof(v1RoleBindingContent));
}
try {
Log.Verbose("Loading k8s RoleBinding definition ...");
var v1RoleBindingDefinition = Yaml
.LoadFromString <V1RoleBinding>(v1RoleBindingContent);
if (null != namespaceParameter)
{
v1RoleBindingDefinition.Metadata.NamespaceProperty = namespaceParameter;
}
Log.Verbose($"Creating k8s RoleBinding: {v1RoleBindingDefinition.Metadata.Name} ...");
var v1RoleBinding = await _k8sClient
.CreateNamespacedRoleBindingAsync(
v1RoleBindingDefinition,
v1RoleBindingDefinition.Metadata.NamespaceProperty,
cancellationToken : cancellationToken
);
Log.Verbose($"Created k8s RoleBinding: {v1RoleBindingDefinition.Metadata.Name}");
return(v1RoleBinding);
}
catch (Exception ex) {
Log.Error(ex, $"Failed to create k8s RoleBinding");
throw;
}
}
public bool CheckIngress(IKubernetes client, IDeserializer deserializer, string path, string key, string value)
{
string curr;
bool match = true;
foreach (string file in Directory.EnumerateFiles(path))
{
var fileContent = System.IO.File.ReadAllText(file);
var ingress = Yaml.LoadFromString <Networkingv1beta1Ingress>(fileContent);
if (ingress == null)
{
match = false;
break;
}
// Check if NetworkPolicy has label - if no label return false
if (ingress.Metadata.Labels == null)
{
match = false;
break;
}
// Check if Ingress has label - if no label return false
ingress.Metadata.Labels.TryGetValue(key, out curr);
// If there is no match at this stage, there is a mismatch
if (value != curr)
{
match = false;
break;
}
}
return(match);
}
static bool CheckNetPol(IKubernetes client, IDeserializer deserializer, string path, string key, string value)
{
string curr = "";
bool match = true;
foreach (string file in Directory.EnumerateFiles(path))
{
var fileContent = System.IO.File.ReadAllText(file);
var netPol = Yaml.LoadFromString <V1NetworkPolicy>(fileContent);
if (netPol == null)
{
match = false;
break;
}
if (netPol.Metadata.Labels != null)
{
netPol.Metadata.Labels.TryGetValue(key, out curr);
}
else
{
match = false;
break;
}
// If there is no match at this stage, there is a error of some kind
if (value != curr)
{
match = false;
break;
}
}
return(match);
}
public void EnvVariableShouldBeStrings()
{
var content = @"apiVersion: v1
kind: Pod
metadata:
name: cpu-demo
spec:
containers:
- env:
- name: PORT
value: ""3000""
image: vish/stress
name: cpu-demo-ctr";
var obj = Yaml.LoadFromString <V1Pod>(content);
Assert.NotNull(obj?.Spec?.Containers);
var container = Assert.Single(obj.Spec.Containers);
Assert.NotNull(container.Env);
var objStr = Yaml.SaveToString(obj);
Assert.Equal(content, objStr);
}
private async Task <V1Service> CreateV1ServiceAsync(
string v1ServiceContent,
string namespaceParameter = null,
CancellationToken cancellationToken = default
)
{
if (string.IsNullOrWhiteSpace(v1ServiceContent))
{
throw new ArgumentNullException(nameof(v1ServiceContent));
}
try {
Log.Verbose("Loading k8s Service definition ...");
var v1Service = Yaml.LoadFromString <V1Service>(v1ServiceContent);
if (null != namespaceParameter)
{
v1Service.Metadata.NamespaceProperty = namespaceParameter;
}
Log.Verbose($"Creating k8s Service: {v1Service.Metadata.Name} ...");
var service = await _k8sClient
.CreateNamespacedServiceAsync(
v1Service,
v1Service.Metadata.NamespaceProperty,
cancellationToken : cancellationToken
);
Log.Verbose($"Created k8s Service: {service.Metadata.Name}");
return(service);
}
catch (Exception ex) {
Log.Error(ex, $"Failed to create k8s Service");
throw;
}
}
public void LoadPropertyNamedReadOnlyFromString()
{
var content = @"apiVersion: v1
kind: Pod
metadata:
namespace: bar
name: foo
spec:
containers:
- image: nginx
volumeMounts:
- name: vm1
mountPath: /vm1
readOnly: true
- name: vm2
mountPath: /vm2
readOnly: false
";
var obj = Yaml.LoadFromString <V1Pod>(content);
Assert.True(obj.Spec.Containers[0].VolumeMounts[0].ReadOnlyProperty);
Assert.False(obj.Spec.Containers[0].VolumeMounts[1].ReadOnlyProperty);
}
public async System.Threading.Tasks.Task <IActionResult> Index(int id)
{
userName = this.User.FindFirstValue(ClaimTypes.NameIdentifier);
var k8SClientConfig = KubernetesClientConfiguration.BuildDefaultConfig();
var client = new Kubernetes(k8SClientConfig);
var optionsBuilder = new DbContextOptionsBuilder <ApplicationDbContext>();
optionsBuilder.UseSqlServer("ApplicationDbContext");
p = _context.Template.Find(id).Path;
HttpContext.Session.SetInt32("TemplateId", id);
var pDeployments = "/etc/athena/Templates/" + p + "/Deployment";
var pServices = "/etc/athena/Templates/" + p + "/Service";
var pIngress = "/etc/athena/Templates/" + p + "/Ingress";
string pNetPol = "/etc/athena/Templates/" + p + "/NetworkPolicy";
try
{
foreach (string file in Directory.EnumerateFiles(pServices))
{
var fileContent = System.IO.File.ReadAllText(file);
var service = Yaml.LoadFromString <V1Service>(fileContent);
var result = client.CreateNamespacedService(service, userName);
}
foreach (string file in Directory.EnumerateFiles(pDeployments))
{
var fileContent = System.IO.File.ReadAllText(file);
var deployment = Yaml.LoadFromString <V1Deployment>(fileContent);
var result = client.CreateNamespacedDeployment(deployment, userName);
}
foreach (string file in Directory.EnumerateFiles(pIngress))
{
var fileContent = System.IO.File.ReadAllText(file);
var ingress = Yaml.LoadFromString <Networkingv1beta1Ingress>(fileContent);
AddIngress(client, ingress, userName);
}
foreach (string file in Directory.EnumerateFiles(pNetPol))
{
V1NetworkPolicy netPol = null;
var fileContent = System.IO.File.ReadAllText(file);
netPol = Yaml.LoadFromString <V1NetworkPolicy>(fileContent);
var result = client.CreateNamespacedNetworkPolicy(netPol, userName);
}
return(View());
}
catch {
return(View());
}
}
public async Task <Networkingv1beta1Ingress> CreateNetworkingv1beta1IngressAsync(
string networkingv1beta1IngressContent,
string namespaceParameter = null,
string ingressHostname = null,
CancellationToken cancellationToken = default
)
{
if (string.IsNullOrWhiteSpace(networkingv1beta1IngressContent))
{
throw new ArgumentNullException(nameof(networkingv1beta1IngressContent));
}
try {
Log.Verbose("Loading k8s Ingress definition ...");
var networkingv1beta1IngressDefinition = Yaml
.LoadFromString <Networkingv1beta1Ingress>(
networkingv1beta1IngressContent
);
if (!string.IsNullOrWhiteSpace(namespaceParameter))
{
networkingv1beta1IngressDefinition.Metadata.NamespaceProperty = namespaceParameter;
}
// If hostname is provided then we will update Spec
if (!string.IsNullOrWhiteSpace(ingressHostname))
{
// Add entry to Spec.Tls
const string secretName = "tls-secret";
var tls = new Networkingv1beta1IngressTLS {
Hosts = new List <string> {
ingressHostname
},
SecretName = secretName
};
if (networkingv1beta1IngressDefinition.Spec.Tls is null)
{
networkingv1beta1IngressDefinition.Spec.Tls =
new List <Networkingv1beta1IngressTLS> {
tls
};
}
else
{
networkingv1beta1IngressDefinition.Spec.Tls.Add(tls);
}
// Set host in Spec.Rules[0]
networkingv1beta1IngressDefinition.Spec.Rules.First().Host = ingressHostname;
}
Log.Verbose($"Creating k8s Ingress: " +
$"{networkingv1beta1IngressDefinition.Metadata.Name} ...");
var networkingv1beta1Ingress = await _k8sClient
.CreateNamespacedIngress1Async(
networkingv1beta1IngressDefinition,
networkingv1beta1IngressDefinition.Metadata.NamespaceProperty,
cancellationToken : cancellationToken
);
Log.Verbose($"Created k8s Ingress: {networkingv1beta1Ingress.Metadata.Name}");
return(networkingv1beta1Ingress);
}
catch (Exception ex) {
Log.Error(ex, $"Failed to create k8s Ingress");
throw;
}
}
public IActionResult Index()
{
string a;
var UserEmail = this.User.Identity.Name;
var result = GetUserRoles(UserEmail, "*****@*****.**", out a);
ViewBag.Tutor = a;
ViewBag.Admin = result;
if (a == "/Staff")
{
HttpContext.Session.SetString("Role", "staff");
}
else
{
HttpContext.Session.SetString("Role", "student");
}
var UserId = this.User.FindFirstValue(ClaimTypes.NameIdentifier);
try
{
var k8SClientConfig = KubernetesClientConfiguration.BuildDefaultConfig();
var client = new Kubernetes(k8SClientConfig);
var namespaces = client.ListNamespace(null, null, "metadata.name=" + UserId);
if (namespaces != null && namespaces.Items.Count > 0)
{
return(View());
}
var ns = new V1Namespace
{
Metadata = new V1ObjectMeta
{
Name = UserId
}
};
var result2 = client.CreateNamespace(ns);
var netPolFile = "default-network-policy.yaml";
if (System.IO.File.Exists(netPolFile))
{
var fileContent = System.IO.File.ReadAllText(netPolFile);
var netPol = Yaml.LoadFromString <V1NetworkPolicy>(fileContent);
client.CreateNamespacedNetworkPolicy(netPol, UserId);
}
ViewData["Message"] = "";
return(View());
}
catch (Exception e)
{
return(RedirectToAction("Error", e));
}
}
public bool CheckDeployments(IKubernetes client, IDeserializer deserializer, string path, string key, out string value)
{
value = null;
string curr;
bool match = true;
foreach (string file in Directory.EnumerateFiles(path))
{
var fileContent = System.IO.File.ReadAllText(file);
var deployment = Yaml.LoadFromString <V1Deployment>(fileContent);
if (deployment == null)
{
match = false;
break;
}
// Check if Deployment has label - if no labels return false
if (deployment.Metadata.Labels != null)
{
deployment.Metadata.Labels.TryGetValue(key, out curr);
}
else
{
match = false;
break;
}
// Matches first Deployment with label, assigns label value to labName
if (value == null)
{
value = curr;
}
// If there is no match at this stage, there is a mismatch
else if (value != curr)
{
match = false;
break;
}
// Checking selectors - all deployments must select based on at least the lab name and that name must match on every template
// Checking MatchLabels
if (deployment.Spec.Selector.MatchLabels != null)
{
deployment.Spec.Selector.MatchLabels.TryGetValue(key, out curr);
if (value != curr)
{
match = false;
break;
}
}
// Checking MatchExpressions
else
{
var expressions = deployment.Spec.Selector.MatchExpressions;
if (expressions != null)
{
foreach (var expression in expressions)
{
if (expression.Key == key && expression.OperatorProperty == "In" && expression.Values.Contains(value))
{
match = true;
break;
}
else
{
match = false;
break;
}
}
}
}
// Checking Pod Spec - label should be present and correct
if (deployment.Spec.Template.Metadata.Labels == null)
{
match = false;
break;
}
deployment.Spec.Template.Metadata.Labels.TryGetValue(key, out curr);
if (value != curr)
{
match = false;
break;
}
}
return(match);
}
