mirror of
https://github.com/apache/cloudstack.git
synced 2025-10-26 08:42:29 +01:00
02f80d3370
As notified in the 4.14.0.0 release notes, this deprecates the legacy UI and moves it under the ui/legacy directory which will be served at /client/legacy URL path. This will also ensure that users upgrading or installing 4.15.0.0 will get the new UI by default. This will also make it simpler to remove the old UI for future 4.16/master releases. Co-authored-by: Daan Hoogland <daan.hoogland@shapeblue.com>
1582 lines
98 KiB
JavaScript
1582 lines
98 KiB
JavaScript
// Licensed to the Apache Software Foundation (ASF) under one
|
|
// or more contributor license agreements. See the NOTICE file
|
|
// distributed with this work for additional information
|
|
// regarding copyright ownership. The ASF licenses this file
|
|
// to you under the Apache License, Version 2.0 (the
|
|
// "License"); you may not use this file except in compliance
|
|
// with the License. You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing,
|
|
// software distributed under the License is distributed on an
|
|
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
// KIND, either express or implied. See the License for the
|
|
// specific language governing permissions and limitations
|
|
// under the License.
|
|
(function (cloudStack) {
|
|
|
|
var rootCaCert = "";
|
|
var downloadCaCert = function() {
|
|
var blob = new Blob([rootCaCert], {type: 'application/x-x509-ca-cert'});
|
|
var filename = "cloudstack-ca.pem";
|
|
if(window.navigator.msSaveOrOpenBlob) {
|
|
window.navigator.msSaveBlob(blob, filename);
|
|
} else{
|
|
var elem = window.document.createElement('a');
|
|
elem.href = window.URL.createObjectURL(blob);
|
|
elem.download = filename;
|
|
document.body.appendChild(elem)
|
|
elem.click();
|
|
document.body.removeChild(elem);
|
|
}
|
|
};
|
|
var clusterKubeConfig = "";
|
|
var downloadClusterKubeConfig = function() {
|
|
var blob = new Blob([clusterKubeConfig], {type: 'text/plain'});
|
|
var filename = "kube.conf";
|
|
if(window.navigator.msSaveOrOpenBlob) {
|
|
window.navigator.msSaveBlob(blob, filename);
|
|
} else{
|
|
var elem = window.document.createElement('a');
|
|
elem.href = window.URL.createObjectURL(blob);
|
|
elem.download = filename;
|
|
document.body.appendChild(elem)
|
|
elem.click();
|
|
document.body.removeChild(elem);
|
|
}
|
|
};
|
|
var minCpu = 0;
|
|
var minRamSize = 0;
|
|
cloudStack.plugins.cks = function(plugin) {
|
|
plugin.ui.addSection({
|
|
id: 'cks',
|
|
title: 'label.kubernetes.service',
|
|
preFilter: function(args) {
|
|
var pluginEnabled = false;
|
|
$.ajax({
|
|
url: createURL('listCapabilities'),
|
|
async: false,
|
|
success: function(json) {
|
|
pluginEnabled = json.listcapabilitiesresponse.capability.kubernetesserviceenabled;
|
|
},
|
|
error: function(XMLHttpResponse) {
|
|
pluginEnabled = false;
|
|
}
|
|
});
|
|
return pluginEnabled;
|
|
},
|
|
showOnNavigation: true,
|
|
sectionSelect: {
|
|
label: 'label.select-view',
|
|
preFilter: function() {
|
|
return ['kubernetesclusters', 'kubernetesversions'];
|
|
}
|
|
},
|
|
sections: {
|
|
kubernetesclusters: {
|
|
id: 'kubernetesclusters',
|
|
type: 'select',
|
|
title: "label.clusters",
|
|
listView: {
|
|
filters: {
|
|
all: {
|
|
label: 'ui.listView.filters.all'
|
|
},
|
|
running: {
|
|
label: 'state.Running'
|
|
},
|
|
stopped: {
|
|
label: 'state.Stopped'
|
|
},
|
|
destroyed: {
|
|
label: 'state.Destroyed'
|
|
}
|
|
},
|
|
fields: {
|
|
name: {
|
|
label: 'label.name'
|
|
},
|
|
zonename: {
|
|
label: 'label.zone.name'
|
|
},
|
|
size : {
|
|
label: 'label.size'
|
|
},
|
|
cpunumber: {
|
|
label: 'label.num.cpu.cores'
|
|
},
|
|
memory: {
|
|
label: 'label.memory.mb'
|
|
},
|
|
state: {
|
|
label: 'label.state',
|
|
indicator: {
|
|
'Running': 'on',
|
|
'Stopped': 'off',
|
|
'Destroyed': 'off',
|
|
'Error': 'off'
|
|
}
|
|
}
|
|
},
|
|
advSearchFields: {
|
|
name: {
|
|
label: 'label.name'
|
|
},
|
|
zoneid: {
|
|
label: 'label.zone',
|
|
select: function(args) {
|
|
$.ajax({
|
|
url: createURL('listZones'),
|
|
data: {
|
|
listAll: true
|
|
},
|
|
success: function(json) {
|
|
var zones = json.listzonesresponse.zone ? json.listzonesresponse.zone : [];
|
|
|
|
args.response.success({
|
|
data: $.map(zones, function(zone) {
|
|
return {
|
|
id: zone.id,
|
|
description: zone.name
|
|
};
|
|
})
|
|
});
|
|
}
|
|
});
|
|
}
|
|
},
|
|
},
|
|
// List view actions
|
|
actions: {
|
|
add: {
|
|
label: 'label.add.kubernetes.cluster',
|
|
createForm: {
|
|
title: 'label.add.kubernetes.cluster',
|
|
preFilter: function(args) {
|
|
args.$form.find('.form-item[rel=masternodes]').find('input[name=masternodes]').val('2');
|
|
args.$form.find('.form-item[rel=size]').find('input[name=size]').val('1');
|
|
var experimentalFeaturesEnabled = false;
|
|
$.ajax({
|
|
url: createURL('listCapabilities'),
|
|
async: false,
|
|
success: function(json) {
|
|
experimentalFeaturesEnabled = json.listcapabilitiesresponse.capability.kubernetesclusterexperimentalfeaturesenabled;
|
|
}
|
|
});
|
|
if (experimentalFeaturesEnabled == true) {
|
|
args.$form.find('.form-item[rel=supportPrivateRegistry]').css('display', 'inline-block');
|
|
}
|
|
},
|
|
fields: {
|
|
name: {
|
|
label: 'label.name',
|
|
//docID: 'Name of the cluster',
|
|
validation: {
|
|
required: true
|
|
}
|
|
},
|
|
description: {
|
|
label: 'label.description',
|
|
//docID: 'helpKubernetesClusterDesc',
|
|
validation: {
|
|
required: true
|
|
}
|
|
},
|
|
zone: {
|
|
label: 'label.zone',
|
|
//docID: 'helpKubernetesClusterZone',
|
|
validation: {
|
|
required: true
|
|
},
|
|
select: function(args) {
|
|
$.ajax({
|
|
url: createURL("listZones&available=true"),
|
|
dataType: "json",
|
|
async: true,
|
|
success: function(json) {
|
|
var items = [];
|
|
var zoneObjs = json.listzonesresponse.zone;
|
|
if (zoneObjs != null) {
|
|
for (var i = 0; i < zoneObjs.length; i++) {
|
|
items.push({
|
|
id: zoneObjs[i].id,
|
|
description: zoneObjs[i].name
|
|
});
|
|
}
|
|
}
|
|
args.response.success({
|
|
data: items
|
|
});
|
|
}
|
|
});
|
|
}
|
|
},
|
|
kubernetesversion: {
|
|
label: 'label.kubernetes.version',
|
|
dependsOn: ['zone'],
|
|
//docID: 'helpKubernetesClusterZone',
|
|
validation: {
|
|
required: true
|
|
},
|
|
select: function(args) {
|
|
var versionObjs;
|
|
var filterData = { zoneid: args.zone };
|
|
$.ajax({
|
|
url: createURL("listKubernetesSupportedVersions"),
|
|
data: filterData,
|
|
dataType: "json",
|
|
async: true,
|
|
success: function(json) {
|
|
var items = [];
|
|
versionObjs = json.listkubernetessupportedversionsresponse.kubernetessupportedversion;
|
|
if (versionObjs != null) {
|
|
for (var i = 0; i < versionObjs.length; i++) {
|
|
if (versionObjs[i].state == 'Enabled' && versionObjs[i].isostate == 'Ready') {
|
|
items.push({
|
|
id: versionObjs[i].id,
|
|
description: versionObjs[i].name
|
|
});
|
|
}
|
|
}
|
|
}
|
|
args.response.success({
|
|
data: items
|
|
});
|
|
}
|
|
});
|
|
|
|
args.$select.change(function() {
|
|
var $form = $(this).closest("form");
|
|
$form.find('.form-item[rel=multimaster]').find('input[name=multimaster]').prop('checked', false);
|
|
$form.find('.form-item[rel=multimaster]').hide();
|
|
$form.find('.form-item[rel=masternodes]').hide();
|
|
var currentVersionId = $(this).val();
|
|
if (currentVersionId != null && versionObjs != null) {
|
|
for (var i = 0; i < versionObjs.length; i++) {
|
|
if (currentVersionId == versionObjs[i].id) {
|
|
if (versionObjs[i].supportsha === true) {
|
|
$form.find('.form-item[rel=multimaster]').css('display', 'inline-block');
|
|
}
|
|
minCpu = 0;
|
|
if (versionObjs[i].mincpunumber != null && versionObjs[i].mincpunumber != undefined) {
|
|
minCpu = versionObjs[i].mincpunumber;
|
|
}
|
|
minRamSize = 0;
|
|
if (versionObjs[i].minmemory != null && versionObjs[i].minmemory != undefined) {
|
|
minRamSize = versionObjs[i].minmemory;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
},
|
|
serviceoffering: {
|
|
label: 'label.menu.service.offerings',
|
|
dependsOn: ['kubernetesversion'],
|
|
//docID: 'helpKubernetesClusterServiceOffering',
|
|
validation: {
|
|
required: true
|
|
},
|
|
select: function(args) {
|
|
$.ajax({
|
|
url: createURL("listServiceOfferings"),
|
|
dataType: "json",
|
|
async: true,
|
|
success: function(json) {
|
|
var offeringObjs = [];
|
|
var items = json.listserviceofferingsresponse.serviceoffering;
|
|
if (items != null) {
|
|
for (var i = 0; i < items.length; i++) {
|
|
if (items[i].iscustomized == false &&
|
|
items[i].cpunumber >= minCpu && items[i].memory >= minRamSize) {
|
|
offeringObjs.push({
|
|
id: items[i].id,
|
|
description: items[i].name
|
|
});
|
|
}
|
|
}
|
|
}
|
|
args.response.success({
|
|
data: offeringObjs
|
|
});
|
|
}
|
|
});
|
|
}
|
|
},
|
|
noderootdisksize: {
|
|
label: 'label.node.root.disk.size.gb',
|
|
//docID: 'helpKubernetesClusterNodeRootDiskSize',
|
|
validation: {
|
|
number: true
|
|
}
|
|
},
|
|
network: {
|
|
label: 'label.network',
|
|
//docID: 'helpKubernetesClusterNetwork',
|
|
select: function(args) {
|
|
$.ajax({
|
|
url: createURL("listNetworks"),
|
|
dataType: "json",
|
|
async: true,
|
|
success: function(json) {
|
|
var networkObjs = [];
|
|
networkObjs.push({
|
|
id: "",
|
|
description: ""
|
|
});
|
|
var items = json.listnetworksresponse.network;
|
|
if (items != null) {
|
|
for (var i = 0; i < items.length; i++) {
|
|
networkObjs.push({
|
|
id: items[i].id,
|
|
description: items[i].name
|
|
});
|
|
}
|
|
}
|
|
args.response.success({
|
|
data: networkObjs
|
|
});
|
|
}
|
|
});
|
|
}
|
|
},
|
|
multimaster: {
|
|
label: "label.ha.enabled",
|
|
dependsOn: 'kubernetesversion',
|
|
isBoolean: true,
|
|
isChecked: false,
|
|
},
|
|
masternodes: {
|
|
label: 'label.master.nodes',
|
|
//docID: 'helpKubernetesClusterSize',
|
|
validation: {
|
|
required: true,
|
|
multiplecountnumber: true
|
|
},
|
|
dependsOn: "multimaster",
|
|
isHidden: true,
|
|
},
|
|
externalloadbalanceripaddress: {
|
|
label: 'label.external.loadbalancer.ip.address',
|
|
validation: {
|
|
ipv4AndIpv6AddressValidator: true
|
|
},
|
|
dependsOn: "multimaster",
|
|
isHidden: true,
|
|
},
|
|
size: {
|
|
label: 'label.cluster.size.worker.nodes',
|
|
//docID: 'helpKubernetesClusterSize',
|
|
validation: {
|
|
required: true,
|
|
naturalnumber: true
|
|
},
|
|
},
|
|
sshkeypair: {
|
|
label: 'label.ssh.key.pair',
|
|
//docID: 'helpKubernetesClusterSSH',
|
|
select: function(args) {
|
|
$.ajax({
|
|
url: createURL("listSSHKeyPairs"),
|
|
dataType: "json",
|
|
async: true,
|
|
success: function(json) {
|
|
var keypairObjs = [];
|
|
keypairObjs.push({
|
|
id: "",
|
|
description: ""
|
|
});
|
|
var items = json.listsshkeypairsresponse.sshkeypair;
|
|
if (items != null) {
|
|
for (var i = 0; i < items.length; i++) {
|
|
keypairObjs.push({
|
|
id: items[i].name,
|
|
description: items[i].name
|
|
});
|
|
}
|
|
}
|
|
args.response.success({
|
|
data: keypairObjs
|
|
});
|
|
}
|
|
});
|
|
}
|
|
},
|
|
supportPrivateRegistry: {
|
|
label: 'label.private.registry',
|
|
isBoolean: true,
|
|
isChecked: false,
|
|
isHidden: true
|
|
},
|
|
username: {
|
|
label: 'label.username',
|
|
dependsOn: 'supportPrivateRegistry',
|
|
validation: {
|
|
required: true
|
|
},
|
|
isHidden: true
|
|
},
|
|
password: {
|
|
label: 'label.password',
|
|
dependsOn: 'supportPrivateRegistry',
|
|
validation: {
|
|
required: true
|
|
},
|
|
isHidden: true,
|
|
isPassword: true
|
|
},
|
|
url: {
|
|
label: 'label.url',
|
|
dependsOn: 'supportPrivateRegistry',
|
|
validation: {
|
|
required: true
|
|
},
|
|
isHidden: true,
|
|
},
|
|
email: {
|
|
label: 'label.email',
|
|
dependsOn: 'supportPrivateRegistry',
|
|
validation: {
|
|
required: true
|
|
},
|
|
isHidden: true,
|
|
}
|
|
}
|
|
},
|
|
|
|
action: function(args) {
|
|
var data = {
|
|
name: args.data.name,
|
|
description: args.data.description,
|
|
zoneid: args.data.zone,
|
|
kubernetesversionid: args.data.kubernetesversion,
|
|
serviceofferingid: args.data.serviceoffering,
|
|
size: args.data.size,
|
|
keypair: args.data.sshkeypair
|
|
};
|
|
|
|
if (args.data.noderootdisksize != null && args.data.noderootdisksize != "" && args.data.noderootdisksize > 0) {
|
|
$.extend(data, {
|
|
noderootdisksize: args.data.noderootdisksize
|
|
});
|
|
}
|
|
|
|
var masterNodes = 1;
|
|
if (args.data.multimaster === 'on') {
|
|
masterNodes = args.data.masternodes;
|
|
if (args.data.externalloadbalanceripaddress != null && args.data.externalloadbalanceripaddress != "") {
|
|
$.extend(data, {
|
|
externalloadbalanceripaddress: args.data.externalloadbalanceripaddress
|
|
});
|
|
}
|
|
}
|
|
$.extend(data, {
|
|
masternodes: masterNodes
|
|
});
|
|
|
|
if (args.data.supportPrivateRegistry) {
|
|
$.extend(data, {
|
|
dockerregistryusername: args.data.username,
|
|
dockerregistrypassword: args.data.password,
|
|
dockerregistryurl: args.data.url,
|
|
dockerregistryemail: args.data.email
|
|
});
|
|
}
|
|
|
|
if (args.data.network != null && args.data.network.length > 0) {
|
|
$.extend(data, {
|
|
networkid: args.data.network
|
|
});
|
|
}
|
|
$.ajax({
|
|
url: createURL('createKubernetesCluster'),
|
|
data: data,
|
|
success: function(json) {
|
|
var jid = json.createkubernetesclusterresponse.jobid;
|
|
args.response.success({
|
|
_custom: {
|
|
jobId: jid
|
|
}
|
|
});
|
|
},
|
|
error: function(XMLHttpResponse) {
|
|
var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
|
|
args.response.error(errorMsg);
|
|
}
|
|
});
|
|
},
|
|
|
|
|
|
messages: {
|
|
notification: function(args) {
|
|
return 'Kubernetes Cluster Add';
|
|
}
|
|
},
|
|
notification: {
|
|
poll: pollAsyncJobResult
|
|
}
|
|
}
|
|
},
|
|
dataProvider: function(args) {
|
|
var data = {
|
|
page: args.page,
|
|
pagesize: pageSize
|
|
};
|
|
listViewDataProvider(args, data);
|
|
if (args.filterBy != null) { //filter dropdown
|
|
if (args.filterBy.kind != null) {
|
|
switch (args.filterBy.kind) {
|
|
case "all":
|
|
break;
|
|
case "running":
|
|
$.extend(data, {
|
|
state: 'Running'
|
|
});
|
|
break;
|
|
case "stopped":
|
|
$.extend(data, {
|
|
state: 'Stopped'
|
|
});
|
|
break;
|
|
case "destroyed":
|
|
$.extend(data, {
|
|
state: 'Destroyed'
|
|
});
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
$.ajax({
|
|
url: createURL("listKubernetesClusters"),
|
|
data: data,
|
|
dataType: "json",
|
|
sync: true,
|
|
success: function(json) {
|
|
var items = [];
|
|
if (json.listkubernetesclustersresponse.kubernetescluster != null) {
|
|
items = json.listkubernetesclustersresponse.kubernetescluster;
|
|
}
|
|
args.response.success({
|
|
actionFilter: cksActionfilter,
|
|
data: items
|
|
});
|
|
}
|
|
});
|
|
},
|
|
|
|
detailView: {
|
|
name: 'label.kubernetes.cluster.details',
|
|
isMaximized: true,
|
|
actions: {
|
|
start: {
|
|
label: 'label.start.kuberentes.cluster',
|
|
action: function(args) {
|
|
$.ajax({
|
|
url: createURL("startKubernetesCluster"),
|
|
data: {"id": args.context.kubernetesclusters[0].id},
|
|
dataType: "json",
|
|
async: true,
|
|
success: function(json) {
|
|
var jid = json.startkubernetesclusterresponse.jobid;
|
|
args.response.success({
|
|
_custom: {
|
|
jobId: jid
|
|
}
|
|
});
|
|
}
|
|
});
|
|
},
|
|
messages: {
|
|
confirm: function(args) {
|
|
return 'message.confirm.start.kubernetes.cluster';
|
|
},
|
|
notification: function(args) {
|
|
return 'Started Kubernetes cluster.';
|
|
}
|
|
},
|
|
notification: {
|
|
poll: pollAsyncJobResult
|
|
}
|
|
},
|
|
stop: {
|
|
label: 'label.stop.kuberentes.cluster',
|
|
action: function(args) {
|
|
$.ajax({
|
|
url: createURL("stopKubernetesCluster"),
|
|
data: {"id": args.context.kubernetesclusters[0].id},
|
|
dataType: "json",
|
|
async: true,
|
|
success: function(json) {
|
|
var jid = json.stopkubernetesclusterresponse.jobid;
|
|
args.response.success({
|
|
_custom: {
|
|
jobId: jid
|
|
}
|
|
});
|
|
}
|
|
});
|
|
},
|
|
messages: {
|
|
confirm: function(args) {
|
|
return 'message.confirm.stop.kubernetes.cluster';
|
|
},
|
|
notification: function(args) {
|
|
return 'Stopped Kubernetes cluster.';
|
|
}
|
|
},
|
|
notification: {
|
|
poll: pollAsyncJobResult
|
|
}
|
|
},
|
|
destroy: {
|
|
label: 'label.destroy.kubernetes.cluster',
|
|
compactLabel: 'label.destroy',
|
|
createForm: {
|
|
title: 'label.destroy.kubernetes.cluster',
|
|
desc: 'label.destroy.kubernetes.cluster',
|
|
isWarning: true,
|
|
fields: {
|
|
}
|
|
},
|
|
messages: {
|
|
confirm: function(args) {
|
|
return 'message.confirm.destroy.kubernetes.cluster';
|
|
},
|
|
notification: function(args) {
|
|
return 'Destroyed Kubernetes cluster.';
|
|
}
|
|
},
|
|
action: function(args) {
|
|
var data = {
|
|
id: args.context.kubernetesclusters[0].id
|
|
};
|
|
$.ajax({
|
|
url: createURL('deleteKubernetesCluster'),
|
|
data: data,
|
|
dataType: "json",
|
|
async: true,
|
|
success: function(json) {
|
|
args.response.success({
|
|
_custom: {
|
|
jobId: json.deletekubernetesclusterresponse.jobid,
|
|
getUpdatedItem: function(json) {
|
|
return { 'toRemove': true };
|
|
}
|
|
}
|
|
});
|
|
}
|
|
});
|
|
},
|
|
notification: {
|
|
poll: pollAsyncJobResult
|
|
}
|
|
},
|
|
downloadKubernetesClusterKubeConfig: {
|
|
label: 'label.download.kubernetes.cluster.config',
|
|
messages: {
|
|
notification: function(args) {
|
|
return 'label.download.kubernetes.cluster.config';
|
|
}
|
|
},
|
|
action: function(args) {
|
|
var data = {
|
|
id: args.context.kubernetesclusters[0].id
|
|
}
|
|
$.ajax({
|
|
url: createURL("getKubernetesClusterConfig"),
|
|
dataType: "json",
|
|
data: data,
|
|
async: false,
|
|
success: function(json) {
|
|
var jsonObj;
|
|
if (json.getkubernetesclusterconfigresponse.clusterconfig != null &&
|
|
json.getkubernetesclusterconfigresponse.clusterconfig.configdata != null ) {
|
|
jsonObj = json.getkubernetesclusterconfigresponse.clusterconfig;
|
|
clusterKubeConfig = jsonObj.configdata;
|
|
downloadClusterKubeConfig();
|
|
args.response.success({});
|
|
} else {
|
|
args.response.error("Unable to retrieve Kubernetes cluster config");
|
|
}
|
|
},
|
|
error: function(XMLHttpResponse) {
|
|
var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
|
|
args.response.error(errorMsg);
|
|
}
|
|
});
|
|
},
|
|
notification: {
|
|
poll: function(args) {
|
|
args.complete();
|
|
}
|
|
}
|
|
},
|
|
scaleKubernetesCluster: {
|
|
label: 'label.scale.kubernetes.cluster',
|
|
messages: {
|
|
notification: function(args) {
|
|
return 'label.scale.kubernetes.cluster';
|
|
}
|
|
},
|
|
createForm: {
|
|
title: 'label.scale.kubernetes.cluster',
|
|
desc: '',
|
|
preFilter: function(args) {
|
|
var options = args.$form.find('.form-item[rel=serviceoffering]').find('option');
|
|
$.each(options, function(optionIndex, option) {
|
|
if ($(option).val() === args.context.kubernetesclusters[0].serviceofferingid) {
|
|
$(option).attr('selected','selected');
|
|
}
|
|
});
|
|
args.$form.find('.form-item[rel=size]').find('input[name=size]').val(args.context.kubernetesclusters[0].size);
|
|
},
|
|
fields: {
|
|
serviceoffering: {
|
|
label: 'label.menu.service.offerings',
|
|
//docID: 'helpKubernetesClusterServiceOffering',
|
|
validation: {
|
|
required: true
|
|
},
|
|
select: function(args) {
|
|
$.ajax({
|
|
url: createURL("listKubernetesSupportedVersions"),
|
|
data: {id: args.context.kubernetesclusters[0].kubernetesversionid},
|
|
dataType: "json",
|
|
async: false,
|
|
success: function(json) {
|
|
var versionObjs = json.listkubernetessupportedversionsresponse.kubernetessupportedversion;
|
|
if (versionObjs != null && versionObjs.length > 0) {
|
|
minCpu = 0;
|
|
if (versionObjs[0].mincpunumber != null && versionObjs[0].mincpunumber != undefined) {
|
|
minCpu = versionObjs[0].mincpunumber;
|
|
}
|
|
minRamSize = 0;
|
|
if (versionObjs[0].minmemory != null && versionObjs[0].minmemory != undefined) {
|
|
minRamSize = versionObjs[0].minmemory;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
$.ajax({
|
|
url: createURL("listServiceOfferings"),
|
|
dataType: "json",
|
|
async: true,
|
|
success: function(json) {
|
|
var offeringObjs = [];
|
|
var items = json.listserviceofferingsresponse.serviceoffering;
|
|
if (items != null) {
|
|
for (var i = 0; i < items.length; i++) {
|
|
if (items[i].iscustomized == false &&
|
|
items[i].cpunumber >= minCpu && items[i].memory >= minRamSize) {
|
|
offeringObjs.push({
|
|
id: items[i].id,
|
|
description: items[i].name
|
|
});
|
|
}
|
|
}
|
|
}
|
|
args.response.success({
|
|
data: offeringObjs
|
|
});
|
|
}
|
|
});
|
|
}
|
|
},
|
|
size: {
|
|
label: 'label.cluster.size',
|
|
//docID: 'helpKubernetesClusterSize',
|
|
validation: {
|
|
required: true,
|
|
number: true
|
|
},
|
|
}
|
|
}
|
|
},
|
|
action: function(args) {
|
|
var data = {
|
|
id: args.context.kubernetesclusters[0].id,
|
|
serviceofferingid: args.data.serviceoffering,
|
|
size: args.data.size
|
|
};
|
|
$.ajax({
|
|
url: createURL('scaleKubernetesCluster'),
|
|
data: data,
|
|
dataType: "json",
|
|
success: function (json) {
|
|
var jid = json.scalekubernetesclusterresponse.jobid;
|
|
args.response.success({
|
|
_custom: {
|
|
jobId: jid,
|
|
getActionFilter: function() {
|
|
return cksActionfilter;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}); //end ajax
|
|
},
|
|
notification: {
|
|
poll: pollAsyncJobResult
|
|
}
|
|
},
|
|
upgradeKubernetesCluster: {
|
|
label: 'label.upgrade.kubernetes.cluster',
|
|
messages: {
|
|
notification: function(args) {
|
|
return 'label.upgrade.kubernetes.cluster';
|
|
}
|
|
},
|
|
createForm: {
|
|
title: 'label.upgrade.kubernetes.cluster',
|
|
desc: '',
|
|
preFilter: function(args) {},
|
|
fields: {
|
|
kubernetesversion: {
|
|
label: 'label.kubernetes.version',
|
|
//docID: 'helpKubernetesClusterZone',
|
|
validation: {
|
|
required: true
|
|
},
|
|
select: function(args) {
|
|
var filterData = { minimumkubernetesversionid: args.context.kubernetesclusters[0].kubernetesversionid };
|
|
$.ajax({
|
|
url: createURL("listKubernetesSupportedVersions"),
|
|
data: filterData,
|
|
dataType: "json",
|
|
async: true,
|
|
success: function(json) {
|
|
var items = [];
|
|
var versionObjs = json.listkubernetessupportedversionsresponse.kubernetessupportedversion;
|
|
if (versionObjs != null) {
|
|
var clusterVersion = null;
|
|
for (var j = 0; j < versionObjs.length; j++) {
|
|
if (versionObjs[j].id == args.context.kubernetesclusters[0].kubernetesversionid) {
|
|
clusterVersion = versionObjs[j];
|
|
break;
|
|
}
|
|
}
|
|
for (var i = 0; i < versionObjs.length; i++) {
|
|
if (versionObjs[i].id != args.context.kubernetesclusters[0].kubernetesversionid &&
|
|
(clusterVersion == null || (clusterVersion != null && versionObjs[i].semanticversion != clusterVersion.semanticversion)) &&
|
|
versionObjs[i].state == 'Enabled' && versionObjs[i].isostate == 'Ready') {
|
|
items.push({
|
|
id: versionObjs[i].id,
|
|
description: versionObjs[i].name
|
|
});
|
|
}
|
|
}
|
|
}
|
|
args.response.success({
|
|
data: items
|
|
});
|
|
}
|
|
});
|
|
}
|
|
},
|
|
}
|
|
},
|
|
action: function(args) {
|
|
var data = {
|
|
id: args.context.kubernetesclusters[0].id,
|
|
kubernetesversionid: args.data.kubernetesversion
|
|
};
|
|
$.ajax({
|
|
url: createURL('upgradeKubernetesCluster'),
|
|
data: data,
|
|
dataType: "json",
|
|
success: function (json) {
|
|
var jid = json.upgradekubernetesclusterresponse.jobid;
|
|
args.response.success({
|
|
_custom: {
|
|
jobId: jid,
|
|
getActionFilter: function() {
|
|
return cksActionfilter;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}); //end ajax
|
|
},
|
|
notification: {
|
|
poll: pollAsyncJobResult
|
|
}
|
|
},
|
|
},
|
|
tabs: {
|
|
// Details tab
|
|
details: {
|
|
title: 'label.details',
|
|
fields: [{
|
|
id: {
|
|
label: 'label.id'
|
|
},
|
|
name: {
|
|
label: 'label.name'
|
|
},
|
|
zonename: {
|
|
label: 'label.zone.name'
|
|
},
|
|
kubernetesversionname: {
|
|
label: 'label.kubernetes.version'
|
|
},
|
|
masternodes : {
|
|
label: 'label.master.nodes'
|
|
},
|
|
size : {
|
|
label: 'label.cluster.size'
|
|
},
|
|
cpunumber: {
|
|
label: 'label.num.cpu.cores'
|
|
},
|
|
memory: {
|
|
label: 'label.memory.mb'
|
|
},
|
|
state: {
|
|
label: 'label.state',
|
|
},
|
|
serviceofferingname: {
|
|
label: 'label.compute.offering'
|
|
},
|
|
associatednetworkname: {
|
|
label: 'label.network'
|
|
},
|
|
keypair: {
|
|
label: 'label.ssh.key.pair'
|
|
}
|
|
}],
|
|
|
|
dataProvider: function(args) {
|
|
$.ajax({
|
|
url: createURL("listKubernetesClusters&id=" + args.context.kubernetesclusters[0].id),
|
|
dataType: "json",
|
|
async: true,
|
|
success: function(json) {
|
|
var jsonObj;
|
|
if (json.listkubernetesclustersresponse.kubernetescluster != null && json.listkubernetesclustersresponse.kubernetescluster.length > 0) {
|
|
jsonObj = json.listkubernetesclustersresponse.kubernetescluster[0];
|
|
}
|
|
args.response.success({
|
|
actionFilter: cksActionfilter,
|
|
data: jsonObj
|
|
});
|
|
}
|
|
});
|
|
}
|
|
},
|
|
clusteraccess: {
|
|
title: 'label.access',
|
|
custom : function (args) {
|
|
var showAccess = function() {
|
|
var state = args.context.kubernetesclusters[0].state;
|
|
if (state == "Created") { // Created
|
|
return jQuery('<br><p>').html("Kubernetes cluster setup is under progress, please check again in few minutes.");
|
|
} else if (state == "Error") { // Error
|
|
return jQuery('<br><p>').html("Kubernetes cluster is in error state, it cannot be accessed.");
|
|
} else if (state == "Destroying") { // Destroying
|
|
return jQuery('<br><p>').html("Kubernetes cluster is in destroying state, it cannot be accessed.");
|
|
} else if (state == "Destroyed") { // Destroyed
|
|
return jQuery('<br><p>').html("Kubernetes cluster is already destroyed, it cannot be accessed.");
|
|
}
|
|
var data = {
|
|
id: args.context.kubernetesclusters[0].kubernetesversionid
|
|
}
|
|
var version = '';
|
|
$.ajax({
|
|
url: createURL("listKubernetesSupportedVersions"),
|
|
dataType: "json",
|
|
data: data,
|
|
async: false,
|
|
success: function(json) {
|
|
var jsonObj;
|
|
if (json.listkubernetessupportedversionsresponse.kubernetessupportedversion != null) {
|
|
version = json.listkubernetessupportedversionsresponse.kubernetessupportedversion[0].semanticversion;
|
|
}
|
|
}
|
|
});
|
|
return jQuery('<br><p>').html("Access Kubernetes cluster<br><br>Download cluster's kubeconfig file using action from Details tab.<br>Download kubectl tool for cluster's Kubernetes version from,<br>Linux: <a href='https://storage.googleapis.com/kubernetes-release/release/v" + version + "/bin/linux/amd64/kubectl'>https://storage.googleapis.com/kubernetes-release/release/v" + version + "/bin/linux/amd64/kubectl</a><br>MacOS: <a href='https://storage.googleapis.com/kubernetes-release/release/v" + version + "/bin/darwin/amd64/kubectl'>https://storage.googleapis.com/kubernetes-release/release/v" + version + "/bin/darwin/amd64/kubectl</a><br>Windows: <a href='https://storage.googleapis.com/kubernetes-release/release/v" + version + "/bin/windows/amd64/kubectl.exe'>https://storage.googleapis.com/kubernetes-release/release/v" + version + "/bin/windows/amd64/kubectl.exe</a><br><br>Using kubectl and kubeconfig file to access cluster<br><code>kubectl --kubeconfig /custom/path/kube.conf {COMMAND}</code><br><br>List pods<br><code>kubectl --kubeconfig /custom/path/kube.conf get pods --all-namespaces</code><br>List nodes<br><code>kubectl --kubeconfig /custom/path/kube.conf get nodes --all-namespaces</code><br>List services<br><code>kubectl --kubeconfig /custom/path/kube.conf get services --all-namespaces</code><br><br>Access dashboard web UI<br>Run proxy locally<br><code>kubectl --kubeconfig /custom/path/kube.conf proxy</code><br>Open URL in browser<br><code><a href='http://localhost:8001/api/v1/namespaces/kubernetes-dashboard/services/https:kubernetes-dashboard:/proxy/'>http://localhost:8001/api/v1/namespaces/kubernetes-dashboard/services/https:kubernetes-dashboard:/proxy/</a></code><br><br>Token for dashboard login can be retrieved using following command<br><code>kubectl --kubeconfig /custom/path/kube.conf describe secret $(kubectl --kubeconfig /custom/path/kube.conf get secrets -n kubernetes-dashboard | grep kubernetes-dashboard-token | awk '{print $1}') -n kubernetes-dashboard</code><br><br>More about accessing dashboard UI, https://kubernetes.io/docs/tasks/access-application-cluster/web-ui-dashboard/#accessing-the-dashboard-ui");
|
|
};
|
|
return showAccess();
|
|
}
|
|
},
|
|
clusterinstances: {
|
|
title: 'label.instances',
|
|
listView: {
|
|
section: 'clusterinstances',
|
|
preFilter: function(args) {
|
|
var hiddenFields = [];
|
|
if (!isAdmin()) {
|
|
hiddenFields.push('instancename');
|
|
}
|
|
return hiddenFields;
|
|
},
|
|
fields: {
|
|
name: {
|
|
label: 'label.name',
|
|
truncate: true
|
|
},
|
|
instancename: {
|
|
label: 'label.internal.name'
|
|
},
|
|
displayname: {
|
|
label: 'label.display.name',
|
|
truncate: true
|
|
},
|
|
ipaddress: {
|
|
label: 'label.ip.address'
|
|
},
|
|
zonename: {
|
|
label: 'label.zone.name'
|
|
},
|
|
state: {
|
|
label: 'label.state',
|
|
indicator: {
|
|
'Running': 'on',
|
|
'Stopped': 'off',
|
|
'Destroyed': 'off',
|
|
'Error': 'off'
|
|
}
|
|
}
|
|
},
|
|
dataProvider: function(args) {
|
|
var data = {};
|
|
listViewDataProvider(args, data);
|
|
|
|
$.ajax({
|
|
url: createURL("listKubernetesClusters"),
|
|
data: {"id": args.context.kubernetesclusters[0].id},
|
|
success: function(json) {
|
|
var items = json.listkubernetesclustersresponse.kubernetescluster;
|
|
|
|
var vmlist = [];
|
|
$.each(items, function(idx, item) {
|
|
if ("virtualmachineids" in item) {
|
|
vmlist = vmlist.concat(item.virtualmachineids);
|
|
}
|
|
});
|
|
|
|
$.extend(data, {
|
|
ids: vmlist.join()
|
|
});
|
|
|
|
if (items && items.length > 0 && items[0].projectid != null &&
|
|
items[0].projectid != undefined && items[0].projectid.length > 0) {
|
|
$.extend(data, {
|
|
projectid: items[0].projectid
|
|
});
|
|
}
|
|
|
|
if (data.ids.length == 0) {
|
|
args.response.success({
|
|
data: []
|
|
});
|
|
} else {
|
|
$.ajax({
|
|
url: createURL('listVirtualMachines'),
|
|
data: data,
|
|
success: function(json) {
|
|
var items = json.listvirtualmachinesresponse.virtualmachine;
|
|
if (items) {
|
|
$.each(items, function(idx, vm) {
|
|
if (vm.nic && vm.nic.length > 0 && vm.nic[0].ipaddress) {
|
|
items[idx].ipaddress = vm.nic[0].ipaddress;
|
|
}
|
|
});
|
|
}
|
|
args.response.success({
|
|
data: items
|
|
});
|
|
},
|
|
error: function(XMLHttpResponse) {
|
|
cloudStack.dialog.notice({
|
|
message: parseXMLHttpResponse(XMLHttpResponse)
|
|
});
|
|
args.response.error();
|
|
}
|
|
});
|
|
}
|
|
}
|
|
});
|
|
},
|
|
}
|
|
},
|
|
firewall: {
|
|
title: 'label.firewall',
|
|
custom: function(args) {
|
|
var data = {
|
|
id: args.context.kubernetesclusters[0].networkid,
|
|
listAll: true
|
|
}
|
|
if (args.context.kubernetesclusters[0].projectid != null &&
|
|
args.context.kubernetesclusters[0].projectid != undefined &&
|
|
args.context.kubernetesclusters[0].projectid.length > 0) {
|
|
$.extend(data, {
|
|
projectid: args.context.kubernetesclusters[0].projectid
|
|
});
|
|
$.extend(args.context, {"projectid": args.context.kubernetesclusters[0].projectid});
|
|
}
|
|
$.ajax({
|
|
url: createURL('listNetworks'),
|
|
data: data,
|
|
async: false,
|
|
dataType: "json",
|
|
success: function(json) {
|
|
var network = json.listnetworksresponse.network;
|
|
$.extend(args.context, {"networks": [network]});
|
|
}
|
|
});
|
|
data = {
|
|
associatedNetworkId: args.context.kubernetesclusters[0].networkid,
|
|
listAll: true,
|
|
forvirtualnetwork: true
|
|
}
|
|
if (args.context.kubernetesclusters[0].projectid != null &&
|
|
args.context.kubernetesclusters[0].projectid != undefined &&
|
|
args.context.kubernetesclusters[0].projectid.length > 0) {
|
|
$.extend(data, {
|
|
projectid: args.context.kubernetesclusters[0].projectid
|
|
});
|
|
}
|
|
$.ajax({
|
|
url: createURL('listPublicIpAddresses'),
|
|
data: data,
|
|
async: false,
|
|
dataType: "json",
|
|
success: function(json) {
|
|
var ips = json.listpublicipaddressesresponse.publicipaddress;
|
|
var fwip = ips[0];
|
|
$.each(ips, function(idx, ip) {
|
|
if (ip.issourcenat || ip.isstaticnat) {
|
|
fwip = ip;
|
|
return false;
|
|
}
|
|
});
|
|
$.extend(args.context, {"ipAddresses": [fwip]});
|
|
}
|
|
});
|
|
return cloudStack.sections.network.sections.ipAddresses.listView.detailView.tabs.ipRules.custom(args);
|
|
},
|
|
},
|
|
}
|
|
}
|
|
}
|
|
},
|
|
kubernetesversions: {
|
|
id: 'kubernetesversions',
|
|
type: 'select',
|
|
title: "label.versions",
|
|
listView: {
|
|
fields: {
|
|
name: {
|
|
label: 'label.name'
|
|
},
|
|
semanticversion: {
|
|
label: 'label.kubernetes.version'
|
|
},
|
|
zonename: {
|
|
label: 'label.zone.name'
|
|
},
|
|
isoname: {
|
|
label: 'label.iso.name'
|
|
},
|
|
isostate: {
|
|
label: 'label.iso.state'
|
|
},
|
|
mincpunumber: {
|
|
label: 'label.min.cpu.cores'
|
|
},
|
|
minmemory: {
|
|
label: 'label.memory.minimum.mb'
|
|
},
|
|
state: {
|
|
label: 'label.state',
|
|
indicator: {
|
|
'Enabled': 'on',
|
|
'Disabled': 'off'
|
|
}
|
|
}
|
|
},
|
|
advSearchFields: {
|
|
name: {
|
|
label: 'label.name'
|
|
},
|
|
zoneid: {
|
|
label: 'label.zone',
|
|
select: function(args) {
|
|
$.ajax({
|
|
url: createURL('listZones'),
|
|
data: {
|
|
listAll: true
|
|
},
|
|
success: function(json) {
|
|
var zones = json.listzonesresponse.zone ? json.listzonesresponse.zone : [];
|
|
|
|
args.response.success({
|
|
data: $.map(zones, function(zone) {
|
|
return {
|
|
id: zone.id,
|
|
description: zone.name
|
|
};
|
|
})
|
|
});
|
|
}
|
|
});
|
|
}
|
|
},
|
|
},
|
|
// List view actions
|
|
actions: {
|
|
add: {
|
|
label: 'label.add.kubernetes.version',
|
|
preFilter: function(args) { return isAdmin(); },
|
|
createForm: {
|
|
title: 'label.add.kubernetes.version',
|
|
preFilter: cloudStack.preFilter.createTemplate,
|
|
fields: {
|
|
version: {
|
|
label: 'label.semantic.version',
|
|
//docID: 'Name of the cluster',
|
|
validation: {
|
|
required: true
|
|
}
|
|
},
|
|
name: {
|
|
label: 'label.name',
|
|
//docID: 'Name of the cluster',
|
|
},
|
|
zone: {
|
|
label: 'label.zone',
|
|
//docID: 'helpKubernetesClusterZone',
|
|
validation: {
|
|
required: true
|
|
},
|
|
select: function(args) {
|
|
$.ajax({
|
|
url: createURL("listZones&available=true"),
|
|
dataType: "json",
|
|
async: true,
|
|
success: function(json) {
|
|
var items = [];
|
|
var zoneObjs = json.listzonesresponse.zone;
|
|
if (zoneObjs != null) {
|
|
for (var i = 0; i < zoneObjs.length; i++) {
|
|
items.push({
|
|
id: zoneObjs[i].id,
|
|
description: zoneObjs[i].name
|
|
});
|
|
}
|
|
}
|
|
items.sort(function(a, b) {
|
|
return a.description.localeCompare(b.description);
|
|
});
|
|
items.unshift({
|
|
id: -1,
|
|
description: 'label.all.zones'
|
|
});
|
|
args.response.success({
|
|
data: items
|
|
});
|
|
}
|
|
});
|
|
}
|
|
},
|
|
isourl: {
|
|
label: 'label.url',
|
|
//docID: 'Name of the cluster',
|
|
validation: {
|
|
required: true
|
|
}
|
|
},
|
|
isochecksum: {
|
|
label: 'label.checksum',
|
|
//docID: 'Name of the cluster',
|
|
},
|
|
mincpunumber: {
|
|
label: 'label.min.cpu.cores',
|
|
validation: {
|
|
required: true,
|
|
number: true
|
|
},
|
|
},
|
|
minmemory: {
|
|
label: 'label.memory.minimum.mb',
|
|
validation: {
|
|
required: true,
|
|
number: true
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
action: function(args) {
|
|
var data = {
|
|
name: args.data.name,
|
|
semanticversion: args.data.version,
|
|
url: args.data.isourl,
|
|
checksum: args.data.isochecksum
|
|
};
|
|
if (args.data.zone != null && args.data.zone != -1) {
|
|
$.extend(data, {
|
|
zoneid: args.data.zone
|
|
});
|
|
}
|
|
if (args.data.mincpunumber != null && args.data.mincpunumber != "" && args.data.mincpunumber > 0) {
|
|
$.extend(data, {
|
|
mincpunumber: args.data.mincpunumber
|
|
});
|
|
}
|
|
if (args.data.minmemory != null && args.data.minmemory != "" && args.data.minmemory > 0) {
|
|
$.extend(data, {
|
|
minmemory: args.data.minmemory
|
|
});
|
|
}
|
|
$.ajax({
|
|
url: createURL('addKubernetesSupportedVersion'),
|
|
data: data,
|
|
success: function(json) {
|
|
var version = json.addkubernetessupportedversionresponse.kubernetessupportedversion;
|
|
args.response.success({
|
|
data: version
|
|
});
|
|
},
|
|
error: function(XMLHttpResponse) {
|
|
var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
|
|
args.response.error(errorMsg);
|
|
}
|
|
});
|
|
},
|
|
messages: {
|
|
notification: function(args) {
|
|
return 'Kubernetes Supported Version Add';
|
|
}
|
|
}
|
|
}
|
|
},
|
|
dataProvider: function(args) {
|
|
var data = {
|
|
page: args.page,
|
|
pagesize: pageSize
|
|
};
|
|
listViewDataProvider(args, data);
|
|
$.ajax({
|
|
url: createURL("listKubernetesSupportedVersions"),
|
|
data: data,
|
|
dataType: "json",
|
|
sync: true,
|
|
success: function(json) {
|
|
var items = [];
|
|
if (json.listkubernetessupportedversionsresponse.kubernetessupportedversion != null) {
|
|
items = json.listkubernetessupportedversionsresponse.kubernetessupportedversion;
|
|
}
|
|
args.response.success({
|
|
data: items
|
|
});
|
|
}
|
|
});
|
|
},
|
|
|
|
detailView: {
|
|
name: 'label.kubernetes.version.details',
|
|
isMaximized: true,
|
|
actions: {
|
|
update: {
|
|
label: 'label.edit',
|
|
messages: {
|
|
notification: function(args) {
|
|
return 'label.update.kubernetes.version';
|
|
}
|
|
},
|
|
createForm: {
|
|
title: 'label.update.kubernetes.version',
|
|
desc: '',
|
|
preFilter: function(args) {
|
|
var formVersion = args.context.kubernetesversions[0];
|
|
$.ajax({
|
|
url: createURL('listKubernetesSupportedVersions'),
|
|
data: {
|
|
id: args.context.kubernetesversions[0].id
|
|
},
|
|
dataType: "json",
|
|
async: false,
|
|
success: function (json) {
|
|
if (json.listkubernetessupportedversionsresponse.kubernetessupportedversion != null &&
|
|
json.listkubernetessupportedversionsresponse.kubernetessupportedversion.length > 0) {
|
|
formVersion = json.listkubernetessupportedversionsresponse.kubernetessupportedversion[0];
|
|
}
|
|
}
|
|
});
|
|
if (formVersion.state != null) {
|
|
var options = args.$form.find('.form-item[rel=state]').find('option');
|
|
$.each(options, function(optionIndex, option) {
|
|
if ($(option).val() === formVersion.state) {
|
|
$(option).attr('selected','selected');
|
|
}
|
|
});
|
|
}
|
|
},
|
|
fields: {
|
|
state: {
|
|
label: 'label.state',
|
|
//docID: 'helpKubernetesClusterZone',
|
|
validation: {
|
|
required: true
|
|
},
|
|
select: function(args) {
|
|
var items = [];
|
|
items.push({
|
|
id: 'Enabled',
|
|
description: 'state.Enabled'
|
|
}, {
|
|
id: 'Disabled',
|
|
description: 'state.Disabled'
|
|
});
|
|
args.response.success({
|
|
data: items
|
|
});
|
|
}
|
|
},
|
|
}
|
|
},
|
|
action: function(args) {
|
|
var data = {
|
|
id: args.context.kubernetesversions[0].id,
|
|
state: args.data.state
|
|
};
|
|
$.ajax({
|
|
url: createURL('updateKubernetesSupportedVersion'),
|
|
data: data,
|
|
dataType: "json",
|
|
success: function (json) {
|
|
var jsonObj;
|
|
if (json.updatekubernetessupportedversionresponse.kubernetessupportedversion != null) {
|
|
jsonObj = json.updatekubernetessupportedversionresponse.kubernetessupportedversion;
|
|
}
|
|
args.response.success({
|
|
data: jsonObj
|
|
});
|
|
},
|
|
error: function(XMLHttpResponse) {
|
|
var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
|
|
args.response.error(errorMsg);
|
|
}
|
|
}); //end ajax
|
|
}
|
|
},
|
|
destroy: {
|
|
label: 'label.delete.kubernetes.version',
|
|
compactLabel: 'label.delete',
|
|
preFilter: function(args) { return isAdmin(); },
|
|
createForm: {
|
|
title: 'label.delete.kubernetes.version',
|
|
desc: 'label.delete.kubernetes.version',
|
|
isWarning: true,
|
|
fields: {}
|
|
},
|
|
messages: {
|
|
confirm: function(args) {
|
|
return 'message.confirm.delete.kubernetes.version';
|
|
},
|
|
notification: function(args) {
|
|
return 'Deleted Kubernetes version.';
|
|
}
|
|
},
|
|
action: function(args) {
|
|
var data = {
|
|
id: args.context.kubernetesversions[0].id
|
|
};
|
|
$.ajax({
|
|
url: createURL('deleteKubernetesSupportedVersion'),
|
|
data: data,
|
|
dataType: "json",
|
|
async: true,
|
|
success: function(json) {
|
|
args.response.success({
|
|
_custom: {
|
|
jobId: json.deletekubernetessupportedversionresponse.jobid,
|
|
getUpdatedItem: function(json) {
|
|
return { 'toRemove': true };
|
|
}
|
|
}
|
|
});
|
|
}
|
|
});
|
|
},
|
|
notification: {
|
|
poll: pollAsyncJobResult
|
|
}
|
|
}
|
|
},
|
|
tabs: {
|
|
// Details tab
|
|
details: {
|
|
title: 'label.details',
|
|
fields: [{
|
|
id: {
|
|
label: 'label.id'
|
|
},
|
|
name: {
|
|
label: 'label.name'
|
|
},
|
|
zonename: {
|
|
label: 'label.zone.name'
|
|
},
|
|
isoid: {
|
|
label: 'label.iso.id'
|
|
},
|
|
isoname: {
|
|
label: 'label.iso.name'
|
|
},
|
|
isostate: {
|
|
label: 'label.iso.name'
|
|
}
|
|
}],
|
|
|
|
dataProvider: function(args) {
|
|
$.ajax({
|
|
url: createURL("listKubernetesSupportedVersions&id=" + args.context.kubernetesversions[0].id),
|
|
dataType: "json",
|
|
async: true,
|
|
success: function(json) {
|
|
var jsonObj;
|
|
if (json.listkubernetessupportedversionsresponse.kubernetessupportedversion != null && json.listkubernetessupportedversionsresponse.kubernetessupportedversion.length > 0) {
|
|
jsonObj = json.listkubernetessupportedversionsresponse.kubernetessupportedversion[0];
|
|
}
|
|
args.response.success({
|
|
data: jsonObj
|
|
});
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
}
|
|
});
|
|
};
|
|
|
|
var cksActionfilter = cloudStack.actionFilter.cksActionfilter = function(args) {
|
|
var jsonObj = args.context.item;
|
|
var allowedActions = [];
|
|
if (jsonObj.state != "Destroyed" && jsonObj.state != "Destroying") {
|
|
if (jsonObj.state == "Stopped") {
|
|
allowedActions.push("start");
|
|
} else {
|
|
allowedActions.push("downloadKubernetesClusterKubeConfig");
|
|
allowedActions.push("stop");
|
|
}
|
|
if (jsonObj.state == "Created" || jsonObj.state == "Running") {
|
|
allowedActions.push("scaleKubernetesCluster");
|
|
allowedActions.push("upgradeKubernetesCluster");
|
|
}
|
|
allowedActions.push("destroy");
|
|
}
|
|
return allowedActions;
|
|
}
|
|
|
|
}(cloudStack));
|