public async Task <bool> CreateNamespaceAsync(string name)
{
logger.LogInformation("Getting cluster information - client - CreateNamespaceAsync");
var kubernetes = await client.LoadBasedOnConfigurationAsync();
logger.LogInformation("Creating namespace");
var ns = new V1Namespace
{
Metadata = new V1ObjectMeta {
Name = name
}
};
try
{
var result = kubernetes.CreateNamespace(ns);
return(true);
}
catch (Exception e)
{
logger.LogError(e.Message);
}
return(false);
}
private static void Main(string[] args)
{
var k8SClientConfig = KubernetesClientConfiguration.BuildConfigFromConfigFile();
IKubernetes client = new Kubernetes(k8SClientConfig);
ListNamespaces(client);
var ns = new V1Namespace {
Metadata = new V1ObjectMeta {
Name = "test"
}
};
var result = client.CreateNamespace(ns);
Console.WriteLine(result);
ListNamespaces(client);
var status = client.DeleteNamespace(ns.Metadata.Name, new V1DeleteOptions());
if (status.HasObject)
{
var obj = status.ObjectView <V1Namespace>();
Console.WriteLine(obj.Status.Phase);
Delete(client, ns.Metadata.Name, 3 * 1000);
}
else
{
Console.WriteLine(status.Message);
}
ListNamespaces(client);
}
private void EnsureGroupNamespace(User user)
{
var groupNamespaceName = user.Spec.GetGroupNamespace();
var kiamolNamespaces = _client.ListNamespace(fieldSelector: $"metadata.name={groupNamespaceName}");
if (!kiamolNamespaces.Items.Any())
{
var groupNamespace = new V1Namespace
{
Metadata = new V1ObjectMeta
{
Name = groupNamespaceName,
Labels = new Dictionary <string, string>()
{
{ "kiamol", "ch20" },
}
}
};
_client.CreateNamespace(groupNamespace);
Console.WriteLine($"** Created group namespace: {groupNamespaceName}");
}
else
{
Console.WriteLine($"** Group namespace exists: {groupNamespaceName}");
}
}
public void ReturnObject()
{
var corev1Namespace = new V1Namespace()
{
Metadata = new V1ObjectMeta()
{
Name = "test name"
},
Status = new V1NamespaceStatus()
{
Phase = "test termating"
}
};
using (var server = new MockKubeApiServer(testOutput, resp: JsonConvert.SerializeObject(corev1Namespace)))
{
var client = new Kubernetes(new KubernetesClientConfiguration
{
Host = server.Uri.ToString()
});
var status = client.DeleteNamespace(new V1DeleteOptions(), "test");
Assert.True(status.HasObject);
var obj = status.ObjectView <V1Namespace>();
Assert.Equal(obj.Metadata.Name, corev1Namespace.Metadata.Name);
Assert.Equal(obj.Status.Phase, corev1Namespace.Status.Phase);
}
}
public async Task CreateNamespace(string namespaceName, string roleName)
{
var ns = new V1Namespace
{
Metadata = new V1ObjectMeta
{
Name = namespaceName,
Annotations = new Dictionary <string, string> {
{ "iam.amazonaws.com/permitted", roleName }
}
}
};
try
{
await _client.CreateNamespaceAsync(ns);
}
catch (HttpOperationException e) when(e.Response.Content.Length != 0)
{
throw new Exception(
"Error occured while communicating with k8s:" + Environment.NewLine +
e.Response.Content
, e
);
}
}
CreateNamespaceAsync(Kubernetes k8sClient)
{
try
{
var namespaceParams = PrepareNamespaceParams(_groupName);
var bodyNamespace = new V1Namespace();
var metaData = new V1ObjectMeta();
metaData.Name = namespaceParams;
bodyNamespace.Metadata = metaData;
var v1Namespace = await k8sClient.CreateNamespaceAsync(bodyNamespace);
var nsModel = new MTANamespaceModel(v1Namespace);
return(new Tuple <MTANamespaceModel, MTAErrorModel>(nsModel, null));
}
catch (HttpOperationException ex)
{
var errorModel = new MTAErrorModel(ex);
return(new Tuple <MTANamespaceModel, MTAErrorModel>(null, errorModel));
}
catch (Exception)
{
throw;
}
}
private async Task<string> DescribeObject(Kubernetes client, V1Namespace ns, V1Event o, StringBuilder buffer)
{
var fetched = await client.ReadNamespacedEventAsync(o.Metadata.Name, ns.Metadata.Name).ConfigureAwait(false);
buffer.AppendLine($"API Veresion: {fetched.ApiVersion}");
buffer.AppendLine($"Kind: {fetched.Kind}");
buffer.AppendLine(DescribeMetadata(fetched.Metadata));
return $"Event - {fetched.Metadata.Name}";
}
public async Task <IActionResult> AddNamespace([FromRoute] string namespaceName)
{
V1Namespace @namespace = await this.kubernetesClient.CreateNamespaceAsync(new V1Namespace(metadata : new V1ObjectMeta(name : namespaceName, labels : new Dictionary <string, string> {
{ "application", "openbrisk" }
})));
return(this.CreatedAtAction("GetNamespace", "Namespaces", new { namespaceName }, namespaceName));
}
private async void OpenKubernetesObjectWindow(V1Namespace namespaceMetadata, object hint)
{
IKubernetesObject kubernetesObject = hint as IKubernetesObject;
if (string.Equals(hint as string, "ns", StringComparison.OrdinalIgnoreCase))
{
kubernetesObject = namespaceMetadata;
}
if (kubernetesObject == null)
{
return;
}
var targetPage = default(TabPage);
for (int i = 0; i < detailViewTabs.TabCount; i++)
{
if (object.ReferenceEquals(detailViewTabs.TabPages[i].Tag, kubernetesObject))
{
targetPage = detailViewTabs.TabPages[i];
break;
}
}
FetchResult content;
try { content = await OpenKubernetesObjectInternal(namespaceMetadata, kubernetesObject); }
catch (Exception ex)
{
content = new FetchResult("Error", ex.ToString());
}
if (targetPage == null)
{
targetPage = new TabPage(kubernetesObject.GetType().ToString())
{
Tag = kubernetesObject,
Text = content.Item1,
};
targetPage.Controls.Add(new RichTextBox()
{
Dock = DockStyle.Fill,
ReadOnly = true,
Text = content.Item2,
MaxLength = Int32.MaxValue,
WordWrap = false,
AutoWordSelection = true,
HideSelection = false,
ScrollBars = RichTextBoxScrollBars.ForcedBoth,
Font = new Font("Consolas", 12f),
});
detailViewTabs.TabPages.Add(targetPage);
}
// TODO: Prevent focus when change visible tab
detailViewTabs.SelectedTab = targetPage;
}
public async Task <string> DescribeObject(Kubernetes client, V1Namespace ns, V1Pod o, StringBuilder buffer)
{
var fetched = await client.ReadNamespacedPodAsync(o.Metadata.Name, ns.Metadata.Name).ConfigureAwait(false);
buffer.AppendLine($"API Veresion: {fetched.ApiVersion}");
buffer.AppendLine($"Kind: {fetched.Kind}");
buffer.AppendLine(ChildForm.DescribeMetadata(fetched.Metadata));
return($"Pod - {fetched.Metadata.Name}");
}
public void Setup()
{
var config = KubernetesClientConfiguration.BuildConfigFromConfigFile("assets/config");
_client = new Kubernetes(config);
_guidNS = Guid.NewGuid().ToString();
_namespace = new V1Namespace {
Metadata = new V1ObjectMeta {
Name = _guidNS
}
};
}
public async Task <IActionResult> GetNamespace([FromRoute] string namespaceName)
{
V1Namespace @namespace = await this.kubernetesClient.ReadNamespaceAsync(namespaceName);
V1ServiceList services = await this.kubernetesClient.ListNamespacedServiceAsync(namespaceParameter : namespaceName, labelSelector : "application=openbrisk");
return(this.Ok(new NamespaceInfo
{
Name = @namespace.Metadata.Name,
FunctionCount = services.Items.Count,
}));
}
public async Task CreateNamespaceAsync(NamespaceName namespaceName)
{
var ns = new V1Namespace
{
Metadata = new V1ObjectMeta
{
Name = namespaceName
}
};
await CreateNamespaceAsync(ns);
}
public Task CreateNamespaceAsync(
V1Namespace body,
string pretty,
CancellationToken cancellationToken = default(CancellationToken)
)
{
return(_kubernetes.CreateNamespaceAsync(
body,
pretty,
cancellationToken
));
}
public static async Task AddNamespaceAsync(this KubernetesClient client)
{
var @namespace = new V1Namespace
{
Metadata = new V1ObjectMeta
{
Name = client.DeviceNamespace
}
};
await client.Kubernetes.CreateNamespaceAsync(@namespace);
}
public IActionResult Post([FromQuery] string name)
{
var ns = new V1Namespace
{
Metadata = new V1ObjectMeta
{
Name = name
}
};
var result = kubeClient.CreateNamespace(ns);
return(Ok());
}
public async Task CreateNamespaceAsync(string namespaceName, string roleName)
{
var ns = new V1Namespace
{
Metadata = new V1ObjectMeta
{
Name = namespaceName,
Annotations = new Dictionary <string, string> {
{ "iam.amazonaws.com/permitted", roleName }
}
}
};
await CreateNamespaceAsync(ns);
}
public async Task CreateNamespaceAsync(string namespaceName, string accountId)
{
var ns = new V1Namespace
{
Metadata = new V1ObjectMeta
{
Name = namespaceName,
Annotations = new Dictionary <string, string> {
{ "iam.amazonaws.com/permitted", IAM.ConstructRoleArn(accountId, ".*") }
}
}
};
await CreateNamespaceAsync(ns);
}
public ActionResult <IEnumerable <string> > CreateNamespace()
{
var config = KubernetesClientConfiguration.BuildConfigFromConfigFile();
var client = new Kubernetes(config);
var ns = new V1Namespace
{
Metadata = new V1ObjectMeta
{
Name = "test"
}
};
var result = client.CreateNamespace(ns);
return(new string[] { "Operation", "Namespace Created" });
}
public ActionResult <IEnumerable <string> > deleteNamespace()
{
var config = KubernetesClientConfiguration.BuildConfigFromConfigFile();
var client = new Kubernetes(config);
var ns = new V1Namespace
{
Metadata = new V1ObjectMeta
{
Name = "test"
}
};
var status = client.DeleteNamespace(new V1DeleteOptions(), ns.Metadata.Name);
return(new string[] { "Operation", "Namespace Deleted" });
}
private async Task CreateNamespaceAsync(V1Namespace @namespace)
{
try
{
await _client.CreateNamespaceAsync(@namespace);
}
catch (HttpOperationException e) when(e.Response.Content.Length != 0)
{
throw new Exception(
"Error occured while communicating with k8s:" + Environment.NewLine +
e.Response.Content
, e
);
}
}
public async Task CreateNamespaceAsync(
NamespaceName namespaceName,
IEnumerable <Label> labels
)
{
var ns = new V1Namespace
{
Metadata = new V1ObjectMeta
{
Name = namespaceName,
Labels = labels.ToDictionary(l => l.Key, l => l.Value)
}
};
await CreateNamespaceAsync(ns);
}
public async Task CreateNamespaceAsync(
NamespaceName namespaceName,
IDictionary <string, string> labels
)
{
var ns = new V1Namespace
{
Metadata = new V1ObjectMeta
{
Name = namespaceName,
Labels = labels
}
};
await CreateNamespaceAsync(ns);
}
public async Task EnsureNamespace()
{
var a1 = await client.ListNamespaceAsync();
foreach (var ns in a1.Items)
{
logger.LogInformation("{0}", ns.Metadata.Name);
}
logger.LogInformation("{0}", a1);
var naso = new V1Namespace
{
Metadata = new V1ObjectMeta {
Name = ns
}
};
await client.CreateNamespaceAsync(naso);
}
private async Task <bool> DeployNamespace(DeployArg arg)
{
var body = new V1Namespace
{
Metadata = new V1ObjectMeta
{
Name = arg.SideChainId
}
};
await K8SRequestHelper.GetClient().CreateNamespaceAsync(body);
var ns = await K8SRequestHelper.GetClient().ReadNamespaceAsync(arg.SideChainId);
var retryCount = 0;
while (true)
{
if (ns.Status.Phase == "Active")
{
break;
}
if (retryCount > GlobalSetting.DeployRetryTime)
{
break;
}
retryCount++;
Thread.Sleep(3000);
ns = await K8SRequestHelper.GetClient().ReadNamespaceAsync(arg.SideChainId);
}
if (retryCount > GlobalSetting.DeployRetryTime)
{
await K8SRequestHelper.GetClient().DeleteNamespaceAsync(new V1DeleteOptions(), arg.SideChainId);
return(false);
}
return(true);
}
private async Task CreateNamespaceAsync(V1Namespace @namespace)
{
try
{
await _client.CreateNamespaceAsync(@namespace);
}
catch (HttpOperationException e) when(e.Response.Content.Contains("\"reason\":\"AlreadyExists\""))
{
throw new NamespaceAlreadyExistException(
$"Namespace: \"{@namespace.Metadata.Name}\" can not be created, it already exits");
}
catch (HttpOperationException e) when(e.Response.Content.Length != 0)
{
throw new Exception(
"Error occured while communicating with k8s:" + Environment.NewLine +
e.Response.Content
, e
);
}
}
//[Fact]
public void GetClientTest()
{
var name = "0x7ef9c60a1283681b895dbeb1f28c0d0d8559";
var body = new V1Namespace
{
Metadata = new V1ObjectMeta
{
Name = name
}
};
K8SRequestHelper.GetClient().CreateNamespace(body);
var space1 = K8SRequestHelper.GetClient().ListNamespace();
Assert.True(space1.Items.Select(n => n.Metadata.Name == name).Any());
K8SRequestHelper.GetClient().DeleteNamespace(new V1DeleteOptions(), name);
var space2 = K8SRequestHelper.GetClient().ListNamespace();
Assert.False(space2.Items.Select(n => n.Metadata.Name == name).Any());
}
public async Task EnsureNamespace()
{
var a1 = await client.ListNamespaceAsync();
logger.LogInformation("Creating namespace {0}", ns);
foreach (var ns in a1.Items)
{
if (ns.Metadata.Name == this.ns)
{
logger.LogInformation("Namespace {0} already exists", ns);
return;
}
}
var naso = new V1Namespace
{
Metadata = new V1ObjectMeta {
Name = ns
}
};
await client.CreateNamespaceAsync(naso);
}
public Task CreateNamespaceAsync(V1Namespace body, bool?pretty = null, CancellationToken cancellationToken = default(CancellationToken))
{
return(Task.CompletedTask);
}
private async Task Update()
{
Item = await State.Client.ReadNamespaceAsync(Name);
StateHasChanged();
}
