mirror of https://github.com/rancher/ui.git
1074 lines
35 KiB
JavaScript
1074 lines
35 KiB
JavaScript
import { get, set, computed, observer } from '@ember/object';
|
|
import { on } from '@ember/object/evented';
|
|
import { inject as service } from '@ember/service';
|
|
import Resource from '@rancher/ember-api-store/models/resource';
|
|
import { hasMany, reference } from '@rancher/ember-api-store/utils/denormalize';
|
|
import ResourceUsage from 'shared/mixins/resource-usage';
|
|
import Grafana from 'shared/mixins/grafana';
|
|
import { equal, alias } from '@ember/object/computed';
|
|
import { resolve } from 'rsvp';
|
|
import C from 'ui/utils/constants';
|
|
import { isEmpty, isEqual } from '@ember/utils';
|
|
import moment from 'moment';
|
|
import jsondiffpatch from 'jsondiffpatch';
|
|
import { isArray } from '@ember/array';
|
|
import Semver from 'semver';
|
|
|
|
const TRUE = 'True';
|
|
const CLUSTER_TEMPLATE_ID_PREFIX = 'cattle-global-data:';
|
|
const SCHEDULE_CLUSTER_SCAN_QUESTION_KEY = 'scheduledClusterScan.enabled';
|
|
|
|
export const DEFAULT_USER_DATA =
|
|
`MIME-Version: 1.0
|
|
Content-Type: multipart/mixed; boundary="==MYBOUNDARY=="
|
|
|
|
--==MYBOUNDARY==
|
|
Content-Type: text/x-shellscript; charset="us-ascii"
|
|
|
|
#!/bin/bash
|
|
echo "Running custom user data script"
|
|
|
|
--==MYBOUNDARY==--\\`;
|
|
|
|
export const DEFAULT_NODE_GROUP_CONFIG = {
|
|
desiredSize: 2,
|
|
diskSize: 20,
|
|
ec2SshKey: '',
|
|
gpu: false,
|
|
imageId: null,
|
|
instanceType: 't3.medium',
|
|
labels: {},
|
|
maxSize: 2,
|
|
minSize: 2,
|
|
nodegroupName: '',
|
|
requestSpotInstances: false,
|
|
resourceTags: {},
|
|
spotInstanceTypes: [],
|
|
subnets: [],
|
|
tags: {},
|
|
type: 'nodeGroup',
|
|
userData: DEFAULT_USER_DATA,
|
|
};
|
|
|
|
export const DEFAULT_EKS_CONFIG = {
|
|
amazonCredentialSecret: '',
|
|
displayName: '',
|
|
imported: false,
|
|
kmsKey: '',
|
|
kubernetesVersion: '',
|
|
loggingTypes: [],
|
|
nodeGroups: [],
|
|
privateAccess: false,
|
|
publicAccess: true,
|
|
publicAccessSources: [],
|
|
region: 'us-west-2',
|
|
secretsEncryption: false,
|
|
securityGroups: [],
|
|
serviceRole: '',
|
|
subnets: [],
|
|
tags: {},
|
|
type: 'eksclusterconfigspec',
|
|
};
|
|
|
|
|
|
export default Resource.extend(Grafana, ResourceUsage, {
|
|
globalStore: service(),
|
|
growl: service(),
|
|
intl: service(),
|
|
router: service(),
|
|
scope: service(),
|
|
|
|
clusterRoleTemplateBindings: hasMany('id', 'clusterRoleTemplateBinding', 'clusterId'),
|
|
etcdbackups: hasMany('id', 'etcdbackup', 'clusterId'),
|
|
namespaces: hasMany('id', 'namespace', 'clusterId'),
|
|
nodePools: hasMany('id', 'nodePool', 'clusterId'),
|
|
nodes: hasMany('id', 'node', 'clusterId'),
|
|
projects: hasMany('id', 'project', 'clusterId'),
|
|
clusterScans: hasMany('id', 'clusterScan', 'clusterId'),
|
|
expiringCerts: null,
|
|
grafanaDashboardName: 'Cluster',
|
|
isMonitoringReady: false,
|
|
_cachedConfig: null,
|
|
clusterTemplate: reference('clusterTemplateId'),
|
|
clusterTemplateRevision: reference('clusterTemplateRevisionId'),
|
|
machines: alias('nodes'),
|
|
roleTemplateBindings: alias('clusterRoleTemplateBindings'),
|
|
isAKS: equal('driver', 'azureKubernetesService'),
|
|
isGKE: equal('driver', 'googleKubernetesEngine'),
|
|
|
|
runningClusterScans: computed.filterBy('clusterScans', 'isRunning', true),
|
|
|
|
conditionsDidChange: on('init', observer('enableClusterMonitoring', 'conditions.@each.status', function() {
|
|
if ( !get(this, 'enableClusterMonitoring') ) {
|
|
return false;
|
|
}
|
|
const conditions = get(this, 'conditions') || [];
|
|
|
|
const ready = conditions.findBy('type', 'MonitoringEnabled');
|
|
|
|
const status = ready && get(ready, 'status') === 'True';
|
|
|
|
if ( status !== get(this, 'isMonitoringReady') ) {
|
|
set(this, 'isMonitoringReady', status);
|
|
}
|
|
})),
|
|
|
|
clusterTemplateDisplayName: computed('clusterTemplate.{displayName,name}', 'clusterTemplateId', function() {
|
|
const displayName = get(this, 'clusterTemplate.displayName');
|
|
const clusterTemplateId = (get(this, 'clusterTemplateId') || '').replace(CLUSTER_TEMPLATE_ID_PREFIX, '');
|
|
|
|
return displayName || clusterTemplateId;
|
|
}),
|
|
|
|
clusterTemplateRevisionDisplayName: computed('clusterTemplateRevision.{displayName,name}', 'clusterTemplateRevisionId', function() {
|
|
const displayName = get(this, 'clusterTemplateRevision.displayName');
|
|
const revisionId = (get(this, 'clusterTemplateRevisionId') || '').replace(CLUSTER_TEMPLATE_ID_PREFIX, '')
|
|
|
|
return displayName || revisionId;
|
|
}),
|
|
|
|
isClusterTemplateUpgradeAvailable: computed('clusterTemplate.latestRevision', 'clusterTemplate.latestRevision.id', 'clusterTemplateRevision.id', function() {
|
|
const latestClusterTemplateRevisionId = get(this, 'clusterTemplate.latestRevision.id');
|
|
const currentClusterTemplateRevisionId = get(this, 'clusterTemplateRevision.id');
|
|
|
|
return latestClusterTemplateRevisionId
|
|
&& currentClusterTemplateRevisionId
|
|
&& currentClusterTemplateRevisionId !== latestClusterTemplateRevisionId;
|
|
}),
|
|
|
|
getAltActionDelete: computed('action.remove', function() { // eslint-disable-line
|
|
return get(this, 'canBulkRemove') ? 'delete' : null;
|
|
}),
|
|
|
|
hasSessionToken: computed('annotations', function() {
|
|
const sessionTokenLabel = `${ (get(this, 'annotations') || {})[C.LABEL.EKS_SESSION_TOKEN] }`;
|
|
let hasSessionToken = false;
|
|
|
|
if (sessionTokenLabel === 'undefined' || sessionTokenLabel === 'false') {
|
|
hasSessionToken = false;
|
|
} else {
|
|
hasSessionToken = true;
|
|
}
|
|
|
|
return hasSessionToken;
|
|
}),
|
|
|
|
canRotateCerts: computed('actionLinks.rotateCertificates', function() {
|
|
return !!this.actionLinks.rotateCertificates;
|
|
}),
|
|
|
|
canRotateEncryptionKey: computed(
|
|
'actionLinks.rotateEncryptionKey',
|
|
'etcdbackups.@each.created',
|
|
'rancherKubernetesEngineConfig.rotateEncryptionKey',
|
|
'rancherKubernetesEngineConfig.services.kubeApi.secretsEncryptionConfig.enabled',
|
|
'transitioning',
|
|
'isActive',
|
|
function() {
|
|
const acceptableTimeFrame = 360;
|
|
const {
|
|
actionLinks: { rotateEncryptionKey }, etcdbackups, rancherKubernetesEngineConfig
|
|
} = this;
|
|
const lastBackup = !isEmpty(etcdbackups) ? get(etcdbackups, 'lastObject') : undefined;
|
|
let diffInMinutes = 0;
|
|
|
|
if (this.transitioning !== 'no' || !this.isActive) {
|
|
return false;
|
|
}
|
|
|
|
if (isEmpty(rancherKubernetesEngineConfig)) {
|
|
return false;
|
|
} else {
|
|
const {
|
|
rotateEncryptionKey = false,
|
|
services: { kubeApi: { secretsEncryptionConfig = null } }
|
|
} = rancherKubernetesEngineConfig;
|
|
|
|
if (!!rotateEncryptionKey || isEmpty(secretsEncryptionConfig) || !get(secretsEncryptionConfig, 'enabled')) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
if (lastBackup) {
|
|
diffInMinutes = moment().diff(lastBackup.created, 'minutes');
|
|
}
|
|
|
|
return rotateEncryptionKey && diffInMinutes <= acceptableTimeFrame;
|
|
}),
|
|
|
|
canBulkRemove: computed('action.remove', function() { // eslint-disable-line
|
|
return get(this, 'hasSessionToken') ? false : true;
|
|
}),
|
|
|
|
canSaveAsTemplate: computed('actionLinks.saveAsTemplate', 'isReady', 'clusterTemplateRevisionId', 'clusterTemplateId', function() {
|
|
let {
|
|
actionLinks,
|
|
isReady,
|
|
clusterTemplateRevisionId,
|
|
clusterTemplateId,
|
|
} = this;
|
|
|
|
if (!isReady) {
|
|
return false;
|
|
}
|
|
|
|
if (clusterTemplateRevisionId || clusterTemplateId) {
|
|
return false;
|
|
}
|
|
|
|
return !!actionLinks.saveAsTemplate;
|
|
}),
|
|
|
|
eksDisplayEksImport: computed('clusterProvider', 'eksConfig.privateAccess', 'eksStatus.upstreamSpec.privateAccess', function() {
|
|
const {
|
|
clusterProvider, eksConfig = {}, eksStatus = {}
|
|
} = this;
|
|
const publicAccess = get(eksStatus, 'upstreamSpec.publicAccess') || get(eksConfig, 'publicAccess') || true;
|
|
const privateAccess = get(eksStatus, 'upstreamSpec.privateAccess') || get(eksConfig, 'privateAccess') || false;
|
|
|
|
if (clusterProvider === 'amazoneksv2' && !publicAccess && privateAccess) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}),
|
|
|
|
canShowAddHost: computed('nodes.[]', 'clusterProvider', 'eksConfig.privateAccess', 'eksStatus.upstreamSpec.privateAccess', function() {
|
|
const {
|
|
clusterProvider, eksConfig = {}, eksStatus = {}
|
|
} = this;
|
|
const publicAccess = get(eksStatus, 'upstreamSpec.publicAccess') || get(eksConfig, 'publicAccess') || true;
|
|
const privateAccess = get(eksStatus, 'upstreamSpec.privateAccess') || get(eksConfig, 'privateAccess') || false;
|
|
const ignored = ['custom', 'import', 'amazoneksv2'];
|
|
const nodes = get(this, 'nodes');
|
|
|
|
if (!ignored.includes(clusterProvider)) {
|
|
return false;
|
|
}
|
|
|
|
// private access requires the ability to run the import command on the cluster
|
|
if (clusterProvider === 'amazoneksv2' && !!publicAccess && privateAccess) {
|
|
return true;
|
|
} else if (clusterProvider !== 'amazoneksv2' && isEmpty(nodes)) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}),
|
|
|
|
configName: computed('driver', 'state', function() {
|
|
const keys = this.allKeys().filter((x) => x.endsWith('Config'));
|
|
|
|
for ( let key, i = 0 ; i < keys.length ; i++ ) {
|
|
key = keys[i];
|
|
if ( get(this, key) ) {
|
|
return key;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}),
|
|
|
|
isReady: computed('conditions.@each.status', function() {
|
|
return this.hasCondition('Ready');
|
|
}),
|
|
|
|
isRKE: computed('configName', function() {
|
|
return get(this, 'configName') === 'rancherKubernetesEngineConfig';
|
|
}),
|
|
|
|
displayLocation: computed('configName', function() {
|
|
const configName = this.configName;
|
|
|
|
if ( configName ) {
|
|
return get(this, `${ configName }.region`) || get(this, `${ configName }.regionId`) || get(this, `${ configName }.location`) || get(this, `${ configName }.zone`) || get(this, `${ configName }.zoneId`);
|
|
}
|
|
|
|
return '';
|
|
}),
|
|
|
|
clusterProvider: computed('configName', 'nodePools.@each.{driver,nodeTemplateId}', 'driver', function() {
|
|
const pools = get(this, 'nodePools') || [];
|
|
const firstPool = pools.objectAt(0);
|
|
|
|
switch ( get(this, 'configName') ) {
|
|
case 'amazonElasticContainerServiceConfig':
|
|
return 'amazoneks';
|
|
case 'eksConfig':
|
|
return 'amazoneksv2';
|
|
case 'azureKubernetesServiceConfig':
|
|
return 'azureaks';
|
|
case 'googleKubernetesEngineConfig':
|
|
return 'googlegke';
|
|
case 'tencentEngineConfig':
|
|
return 'tencenttke';
|
|
case 'huaweiEngineConfig':
|
|
return 'huaweicce';
|
|
case 'okeEngineConfig':
|
|
return 'oracleoke';
|
|
case 'lkeEngineConfig':
|
|
return 'linodelke';
|
|
case 'rke2Config':
|
|
return 'rke2';
|
|
case 'rancherKubernetesEngineConfig':
|
|
if ( !pools.length ) {
|
|
return 'custom';
|
|
}
|
|
|
|
return firstPool.driver || get(firstPool, 'nodeTemplate.driver') || null;
|
|
default:
|
|
if (get(this, 'driver')) {
|
|
return get(this, 'driver');
|
|
} else {
|
|
return 'import';
|
|
}
|
|
}
|
|
}),
|
|
|
|
displayProvider: computed('configName', 'driver', 'intl.locale', 'nodePools.@each.displayProvider', 'provider', function() {
|
|
const intl = get(this, 'intl');
|
|
const pools = get(this, 'nodePools');
|
|
const firstPool = (pools || []).objectAt(0);
|
|
const configName = get(this, 'configName');
|
|
const driverName = get(this, 'driver');
|
|
|
|
switch ( configName ) {
|
|
case 'amazonElasticContainerServiceConfig':
|
|
case 'eksConfig':
|
|
return intl.t('clusterNew.amazoneks.shortLabel');
|
|
case 'azureKubernetesServiceConfig':
|
|
return intl.t('clusterNew.azureaks.shortLabel');
|
|
case 'googleKubernetesEngineConfig':
|
|
return intl.t('clusterNew.googlegke.shortLabel');
|
|
case 'tencentEngineConfig':
|
|
return intl.t('clusterNew.tencenttke.shortLabel');
|
|
case 'aliyunEngineConfig':
|
|
return intl.t('clusterNew.aliyunack.shortLabel');
|
|
case 'huaweiEngineConfig':
|
|
return intl.t('clusterNew.huaweicce.shortLabel');
|
|
case 'okeEngineConfig':
|
|
return intl.t('clusterNew.oracleoke.shortLabel');
|
|
case 'otccceEngineConfig':
|
|
return intl.t('clusterNew.otccce.shortLabel');
|
|
case 'lkeEngineConfig':
|
|
return intl.t('clusterNew.linodelke.shortLabel');
|
|
case 'k3sConfig':
|
|
return intl.t('clusterNew.k3simport.shortLabel');
|
|
case 'rke2Config':
|
|
case 'rancherKubernetesEngineConfig':
|
|
var shortLabel;
|
|
|
|
if (configName === 'rancherKubernetesEngineConfig') {
|
|
if (this.provider === 'rke.windows') {
|
|
shortLabel = 'clusterNew.rkeWindows.shortLabel'
|
|
} else {
|
|
shortLabel = 'clusterNew.rke.shortLabel'
|
|
}
|
|
} else {
|
|
shortLabel = 'clusterNew.rke2.shortLabel';
|
|
}
|
|
|
|
if ( !!pools ) {
|
|
if ( firstPool ) {
|
|
return get(firstPool, 'displayProvider') ? get(firstPool, 'displayProvider') : intl.t(shortLabel);
|
|
} else {
|
|
return intl.t(shortLabel);
|
|
}
|
|
} else {
|
|
return intl.t('clusterNew.custom.shortLabel');
|
|
}
|
|
default:
|
|
if (driverName) {
|
|
switch (driverName) {
|
|
case 'rancherd':
|
|
return intl.t('clusterNew.rancherd.shortLabel');
|
|
default:
|
|
return driverName.capitalize();
|
|
}
|
|
} else {
|
|
return intl.t('clusterNew.import.shortLabel');
|
|
}
|
|
}
|
|
}),
|
|
|
|
systemProject: computed('projects.@each.isSystemProject', function() {
|
|
let projects = (get(this, 'projects') || []).filterBy('isSystemProject', true);
|
|
|
|
return get(projects, 'firstObject');
|
|
}),
|
|
|
|
canSaveMonitor: computed('actionLinks.{editMonitoring,enableMonitoring}', 'enableClusterMonitoring', function() {
|
|
const action = get(this, 'enableClusterMonitoring') ? 'editMonitoring' : 'enableMonitoring';
|
|
|
|
return !!this.hasAction(action)
|
|
}),
|
|
|
|
canDisableMonitor: computed('actionLinks.disableMonitoring', function() {
|
|
return !!this.hasAction('disableMonitoring')
|
|
}),
|
|
|
|
defaultProject: computed('projects.@each.{name,clusterOwner}', function() {
|
|
let projects = get(this, 'projects') || [];
|
|
|
|
let out = projects.findBy('isDefault');
|
|
|
|
if ( out ) {
|
|
return out;
|
|
}
|
|
|
|
out = projects.findBy('clusterOwner', true);
|
|
if ( out ) {
|
|
return out;
|
|
}
|
|
|
|
out = projects.objectAt(0);
|
|
|
|
return out;
|
|
}),
|
|
|
|
nodeGroupVersionUpdate: computed('eksStatus.upstreamSpec.kubernetesVersion', 'eksStatus.upstreamSpec.nodeGroups.@each.version', function() {
|
|
if (isEmpty(get(this, 'eksStatus.upstreamSpec.nodeGroups'))) {
|
|
return false;
|
|
}
|
|
|
|
const kubernetesVersion = get(this, 'eksStatus.upstreamSpec.kubernetesVersion');
|
|
const nodeGroupVersions = (get(this, 'eksStatus.upstreamSpec.nodeGroups') || []).getEach('version');
|
|
|
|
return nodeGroupVersions.any((ngv) => {
|
|
if (isEmpty(ngv)) {
|
|
return false;
|
|
} else {
|
|
return Semver.lt(Semver.coerce(ngv), Semver.coerce(kubernetesVersion));
|
|
}
|
|
});
|
|
}),
|
|
|
|
|
|
certsExpiring: computed('certificatesExpiration', function() {
|
|
let { certificatesExpiration = {}, expiringCerts } = this;
|
|
|
|
if (!expiringCerts) {
|
|
expiringCerts = [];
|
|
}
|
|
|
|
if (!isEmpty(certificatesExpiration)) {
|
|
let expKeys = Object.keys(certificatesExpiration);
|
|
|
|
expKeys.forEach((kee) => {
|
|
let certDate = get(certificatesExpiration[kee], 'expirationDate');
|
|
const expirey = moment(certDate);
|
|
let diff = expirey.diff(moment());
|
|
|
|
if (diff < 2592000000) { // milliseconds in a month
|
|
expiringCerts.pushObject({
|
|
expiringCertName: kee,
|
|
milliUntil: diff,
|
|
exactDateTime: certDate
|
|
});
|
|
}
|
|
});
|
|
|
|
set(this, 'expiringCerts', expiringCerts);
|
|
|
|
return expiringCerts.length > 0;
|
|
}
|
|
|
|
return false;
|
|
}),
|
|
|
|
availableActions: computed('actionLinks.{rotateCertificates,rotateEncryptionKey}', 'canRotateEncryptionKey', 'canSaveAsTemplate', 'canShowAddHost', 'eksDisplayEksImport', 'isClusterScanDisabled', function() {
|
|
const a = get(this, 'actionLinks') || {};
|
|
|
|
return [
|
|
{
|
|
label: 'action.rotate',
|
|
icon: 'icon icon-history',
|
|
action: 'rotateCertificates',
|
|
enabled: !!a.rotateCertificates,
|
|
},
|
|
{
|
|
label: 'action.rotateEncryption',
|
|
icon: 'icon icon-key',
|
|
action: 'rotateEncryptionKey',
|
|
enabled: !!this.canRotateEncryptionKey,
|
|
// enabled: true
|
|
},
|
|
{
|
|
label: 'action.backupEtcd',
|
|
icon: 'icon icon-history',
|
|
action: 'backupEtcd',
|
|
enabled: !!a.backupEtcd,
|
|
},
|
|
{
|
|
label: 'action.restoreFromEtcdBackup',
|
|
icon: 'icon icon-history',
|
|
action: 'restoreFromEtcdBackup',
|
|
enabled: !!a.restoreFromEtcdBackup,
|
|
},
|
|
{
|
|
label: 'action.saveAsTemplate',
|
|
icon: 'icon icon-file',
|
|
action: 'saveAsTemplate',
|
|
enabled: this.canSaveAsTemplate,
|
|
},
|
|
{
|
|
label: this.eksDisplayEksImport ? 'action.importHost' : 'action.registration',
|
|
icon: 'icon icon-host',
|
|
action: 'showCommandModal',
|
|
enabled: this.canShowAddHost,
|
|
},
|
|
{
|
|
label: 'action.runCISScan',
|
|
icon: 'icon icon-play',
|
|
action: 'runCISScan',
|
|
enabled: !this.isClusterScanDisabled,
|
|
},
|
|
];
|
|
}),
|
|
|
|
isVxlan: computed('rancherKubernetesEngineConfig.network.options.flannel_backend_type', function() {
|
|
const backend = get(this, 'rancherKubernetesEngineConfig.network.options.flannel_backend_type');
|
|
|
|
return backend === 'vxlan';
|
|
}),
|
|
|
|
isWindows: computed('windowsPreferedCluster', function() {
|
|
return !!get(this, 'windowsPreferedCluster');
|
|
}),
|
|
|
|
isClusterScanDown: computed('systemProject', 'state', 'actionLinks.runSecurityScan', 'isWindows', function() {
|
|
return !get(this, 'systemProject')
|
|
|| get(this, 'state') !== 'active'
|
|
|| !get(this, 'actionLinks.runSecurityScan')
|
|
|| get(this, 'isWindows');
|
|
}),
|
|
|
|
isAddClusterScanScheduleDisabled: computed('isClusterScanDown', 'scheduledClusterScan.enabled', 'clusterTemplateRevision', 'clusterTemplateRevision.questions.[]', function() {
|
|
if (get(this, 'clusterTemplateRevision') === null) {
|
|
return get(this, 'isClusterScanDown');
|
|
}
|
|
|
|
if (get(this, 'isClusterScanDown')) {
|
|
return true;
|
|
}
|
|
|
|
if (get(this, 'scheduledClusterScan.enabled')) {
|
|
return false;
|
|
}
|
|
|
|
return !get(this, 'clusterTemplateRevision.questions')
|
|
|| get(this, 'clusterTemplateRevision.questions').every((question) => question.variable !== SCHEDULE_CLUSTER_SCAN_QUESTION_KEY)
|
|
}),
|
|
|
|
isClusterScanDisabled: computed('runningClusterScans.length', 'isClusterScanDown', function() {
|
|
return (get(this, 'runningClusterScans.length') > 0)
|
|
|| get(this, 'isClusterScanDown');
|
|
}),
|
|
|
|
unhealthyComponents: computed('componentStatuses.@each.conditions', function() {
|
|
return (get(this, 'componentStatuses') || [])
|
|
.filter((s) => !(s.conditions || []).any((c) => c.status === 'True'));
|
|
}),
|
|
|
|
masterNodes: computed('nodes.@each.{state,labels}', function() {
|
|
return (this.nodes || []).filter((node) => node.labels && node.labels[C.NODES.MASTER_NODE]);
|
|
}),
|
|
|
|
inactiveNodes: computed('nodes.@each.state', function() {
|
|
return (get(this, 'nodes') || []).filter( (n) => C.ACTIVEISH_STATES.indexOf(get(n, 'state')) === -1 );
|
|
}),
|
|
|
|
unhealthyNodes: computed('nodes.@each.conditions', function() {
|
|
const out = [];
|
|
|
|
(get(this, 'nodes') || []).forEach((n) => {
|
|
const conditions = get(n, 'conditions') || [];
|
|
const outOfDisk = conditions.find((c) => c.type === 'OutOfDisk');
|
|
const diskPressure = conditions.find((c) => c.type === 'DiskPressure');
|
|
const memoryPressure = conditions.find((c) => c.type === 'MemoryPressure');
|
|
|
|
if ( outOfDisk && get(outOfDisk, 'status') === TRUE ) {
|
|
out.push({
|
|
displayName: get(n, 'displayName'),
|
|
error: 'outOfDisk'
|
|
});
|
|
}
|
|
|
|
if ( diskPressure && get(diskPressure, 'status') === TRUE ) {
|
|
out.push({
|
|
displayName: get(n, 'displayName'),
|
|
error: 'diskPressure'
|
|
});
|
|
}
|
|
|
|
if ( memoryPressure && get(memoryPressure, 'status') === TRUE ) {
|
|
out.push({
|
|
displayName: get(n, 'displayName'),
|
|
error: 'memoryPressure'
|
|
});
|
|
}
|
|
});
|
|
|
|
return out;
|
|
}),
|
|
|
|
displayWarnings: computed('unhealthyNodes.[]', 'clusterProvider', 'inactiveNodes.[]', 'unhealthyComponents.[]', function() {
|
|
const intl = get(this, 'intl');
|
|
const out = [];
|
|
const unhealthyComponents = get(this, 'unhealthyComponents') || [];
|
|
const inactiveNodes = get(this, 'inactiveNodes') || [];
|
|
const unhealthyNodes = get(this, 'unhealthyNodes') || [];
|
|
const clusterProvider = get(this, 'clusterProvider');
|
|
|
|
const grayOut = C.GRAY_OUT_SCHEDULER_STATUS_PROVIDERS.indexOf(clusterProvider) > -1;
|
|
|
|
unhealthyComponents.forEach((component) => {
|
|
if ( grayOut && (get(component, 'name') === 'scheduler' || get(component, 'name') === 'controller-manager') ) {
|
|
return;
|
|
}
|
|
out.pushObject(intl.t('clusterDashboard.alert.component', { component: get(component, 'name') }));
|
|
});
|
|
|
|
inactiveNodes.forEach((node) => {
|
|
out.pushObject(intl.t('clusterDashboard.alert.node', { node: get(node, 'displayName') }))
|
|
});
|
|
|
|
unhealthyNodes.forEach((node) => {
|
|
out.pushObject(intl.t(`clusterDashboard.alert.nodeCondition.${ get(node, 'error') }`, { node: get(node, 'displayName') }))
|
|
});
|
|
|
|
return out;
|
|
}),
|
|
|
|
actions: {
|
|
backupEtcd() {
|
|
const getBackupType = () => {
|
|
let services = get(this, 'rancherKubernetesEngineConfig.services.etcd');
|
|
|
|
if (get(services, 'cachedConfig')) {
|
|
if (isEmpty(services.cachedConfig.s3BackupConfig)) {
|
|
return 'local';
|
|
} else if (!isEmpty(services.cachedConfig.s3BackupConfig)) {
|
|
return 's3';
|
|
}
|
|
}
|
|
}
|
|
|
|
const backupType = getBackupType();
|
|
const successTitle = this.intl.t('action.backupEtcdMessage.success.title');
|
|
const successMessage = this.intl.t('action.backupEtcdMessage.success.message', {
|
|
clusterId: this.displayName || this.id,
|
|
backupType
|
|
});
|
|
|
|
this.doAction('backupEtcd')
|
|
.then(() => this.growl.success(successTitle, successMessage))
|
|
.catch((err) => this.growl.fromError(err));
|
|
},
|
|
|
|
restoreFromEtcdBackup(options) {
|
|
get(this, 'modalService').toggleModal('modal-restore-backup', {
|
|
cluster: this,
|
|
selection: (options || {}).selection
|
|
});
|
|
},
|
|
|
|
promptDelete() {
|
|
const hasSessionToken = get(this, 'canBulkRemove') ? false : true; // canBulkRemove returns true of the session token is set false
|
|
|
|
if (hasSessionToken) {
|
|
set(this, `${ get(this, 'configName') }.accessKey`, null);
|
|
get(this, 'modalService').toggleModal('modal-delete-eks-cluster', { model: this, });
|
|
} else {
|
|
get(this, 'modalService').toggleModal('confirm-delete', {
|
|
escToClose: true,
|
|
resources: [this]
|
|
});
|
|
}
|
|
},
|
|
|
|
edit(additionalQueryParams = {}) {
|
|
let provider = get(this, 'clusterProvider') || get(this, 'driver');
|
|
let queryParams = {
|
|
queryParams: {
|
|
provider,
|
|
...additionalQueryParams
|
|
}
|
|
};
|
|
|
|
if (provider === 'amazoneks' && !isEmpty(get(this, 'eksConfig'))) {
|
|
set(queryParams, 'queryParams.provider', 'amazoneksv2');
|
|
}
|
|
|
|
if (this.clusterTemplateRevisionId) {
|
|
set(queryParams, 'queryParams.clusterTemplateRevision', this.clusterTemplateRevisionId);
|
|
}
|
|
|
|
this.router.transitionTo('authenticated.cluster.edit', get(this, 'id'), queryParams);
|
|
},
|
|
|
|
scaleDownPool(id) {
|
|
const pool = (get(this, 'nodePools') || []).findBy('id', id);
|
|
|
|
if ( pool ) {
|
|
pool.incrementQuantity(-1);
|
|
}
|
|
},
|
|
|
|
scaleUpPool(id) {
|
|
const pool = (get(this, 'nodePools') || []).findBy('id', id);
|
|
|
|
if ( pool ) {
|
|
pool.incrementQuantity(1);
|
|
}
|
|
},
|
|
|
|
saveAsTemplate() {
|
|
this.modalService.toggleModal('modal-save-rke-template', { cluster: this });
|
|
},
|
|
|
|
runCISScan(options) {
|
|
this.get('modalService').toggleModal('run-scan-modal', {
|
|
closeWithOutsideClick: true,
|
|
cluster: this,
|
|
onRun: (options || {}).onRun
|
|
});
|
|
},
|
|
|
|
rotateCertificates() {
|
|
const model = this;
|
|
|
|
get(this, 'modalService').toggleModal('modal-rotate-certificates', {
|
|
model,
|
|
serviceDefaults: get(this, 'globalStore').getById('schema', 'rotatecertificateinput').optionsFor('services'),
|
|
});
|
|
},
|
|
|
|
rotateEncryptionKey() {
|
|
const model = this;
|
|
|
|
get(this, 'modalService').toggleModal('modal-rotate-encryption-key', { model, });
|
|
},
|
|
|
|
showCommandModal() {
|
|
this.modalService.toggleModal('modal-show-command', { cluster: this });
|
|
},
|
|
},
|
|
|
|
clearConfigFieldsForClusterTemplate() {
|
|
let clearedNull = ['localClusterAuthEndpoint', 'rancherKubernetesEngineConfig', 'enableNetworkPolicy'];
|
|
let clearedDelete = ['defaultClusterRoleForProjectMembers', 'defaultPodSecurityPolicyTemplateId'];
|
|
let {
|
|
localClusterAuthEndpoint,
|
|
rancherKubernetesEngineConfig,
|
|
enableNetworkPolicy,
|
|
defaultClusterRoleForProjectMembers,
|
|
defaultPodSecurityPolicyTemplateId,
|
|
} = this;
|
|
|
|
let cachedConfig = {
|
|
localClusterAuthEndpoint,
|
|
rancherKubernetesEngineConfig,
|
|
enableNetworkPolicy,
|
|
defaultClusterRoleForProjectMembers,
|
|
defaultPodSecurityPolicyTemplateId,
|
|
};
|
|
|
|
// set this incase we fail to save the cluster;
|
|
set(this, '_cachedConfig', cachedConfig);
|
|
|
|
clearedDelete.forEach((c) => delete this[c]);
|
|
clearedNull.forEach((c) => set(this, c, null));
|
|
},
|
|
|
|
clearProvidersExcept(keep) {
|
|
const keys = this.allKeys().filter((x) => x.endsWith('Config'));
|
|
|
|
for ( let key, i = 0 ; i < keys.length ; i++ ) {
|
|
key = keys[i];
|
|
if ( key !== keep && get(this, key) ) {
|
|
set(this, key, null);
|
|
}
|
|
}
|
|
},
|
|
|
|
delete(/* arguments*/) {
|
|
const promise = this._super.apply(this, arguments);
|
|
|
|
return promise.then((/* resp */) => {
|
|
if (get(this, 'scope.currentCluster.id') === get(this, 'id')) {
|
|
get(this, 'router').transitionTo('global-admin.clusters');
|
|
}
|
|
});
|
|
},
|
|
|
|
getOrCreateToken() {
|
|
const globalStore = get(this, 'globalStore');
|
|
const id = get(this, 'id');
|
|
|
|
return globalStore.findAll('clusterRegistrationToken', { forceReload: true }).then((tokens) => {
|
|
let token = tokens.filterBy('clusterId', id)[0];
|
|
|
|
if ( token ) {
|
|
return resolve(token);
|
|
} else {
|
|
token = get(this, 'globalStore').createRecord({
|
|
type: 'clusterRegistrationToken',
|
|
clusterId: id
|
|
});
|
|
|
|
return token.save();
|
|
}
|
|
});
|
|
},
|
|
|
|
waitForClusterTemplateToBeAttached() {
|
|
return this._waitForTestFn(() => {
|
|
return this.hasClusterTemplate();
|
|
}, `Wait for Cluster Template to be attached`);
|
|
},
|
|
|
|
hasClusterTemplate() {
|
|
const { clusterTemplateId, clusterTemplateRevisionId } = this;
|
|
|
|
if (isEmpty(clusterTemplateId) && isEmpty(clusterTemplateRevisionId)) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
},
|
|
|
|
save(opt) {
|
|
const { globalStore, eksConfig } = this;
|
|
|
|
if (get(this, 'driver') === 'EKS' || (this.isObject(get(this, 'eksConfig')) && !this.isEmptyObject(get(this, 'eksConfig')))) {
|
|
const options = ({
|
|
...opt,
|
|
data: {
|
|
name: this.name,
|
|
eksConfig: {},
|
|
}
|
|
});
|
|
const eksClusterConfigSpec = globalStore.getById('schema', 'eksclusterconfigspec');
|
|
const nodeGroupConfigSpec = globalStore.getById('schema', 'nodegroup');
|
|
|
|
if (isEmpty(this.id)) {
|
|
sanitizeConfigs(eksClusterConfigSpec, nodeGroupConfigSpec);
|
|
|
|
if (!get(this, 'eksConfig.imported') && this.name !== get(this, 'eksConfig.displayName')) {
|
|
set(this, 'eksConfig.displayName', this.name);
|
|
}
|
|
|
|
return this._super(...arguments);
|
|
} else {
|
|
const config = jsondiffpatch.clone(get(this, 'eksConfig'));
|
|
const upstreamSpec = jsondiffpatch.clone(get(this, 'eksStatus.upstreamSpec'));
|
|
|
|
if (isEmpty(upstreamSpec)) {
|
|
sanitizeConfigs(eksClusterConfigSpec, nodeGroupConfigSpec);
|
|
|
|
return this._super(...arguments);
|
|
}
|
|
|
|
set(options, 'data.eksConfig', this.diffEksUpstream(upstreamSpec, config));
|
|
|
|
if (!isEmpty(get(options, 'data.eksConfig.nodeGroups'))) {
|
|
get(options, 'data.eksConfig.nodeGroups').forEach((ng) => {
|
|
replaceNullWithEmptyDefaults(ng, get(nodeGroupConfigSpec, 'resourceFields'));
|
|
});
|
|
}
|
|
|
|
if (get(options, 'qp._replace')) {
|
|
delete options.qp['_replace'];
|
|
}
|
|
|
|
return this._super(options);
|
|
}
|
|
} else {
|
|
return this._super(...arguments);
|
|
}
|
|
|
|
function sanitizeConfigs(eksClusterConfigSpec, nodeGroupConfigSpec) {
|
|
replaceNullWithEmptyDefaults(eksConfig, get(eksClusterConfigSpec, 'resourceFields'));
|
|
|
|
if (!isEmpty(get(eksConfig, 'nodeGroups'))) {
|
|
get(eksConfig, 'nodeGroups').forEach((ng) => {
|
|
replaceNullWithEmptyDefaults(ng, get(nodeGroupConfigSpec, 'resourceFields'));
|
|
});
|
|
}
|
|
}
|
|
|
|
function replaceNullWithEmptyDefaults(config, resourceFields) {
|
|
Object.keys(config).forEach((ck) => {
|
|
const configValue = get(config, ck);
|
|
|
|
if (configValue === null || typeof configValue === 'undefined') {
|
|
const resourceField = resourceFields[ck];
|
|
|
|
if (resourceField.type === 'string') {
|
|
set(config, ck, '');
|
|
} else if (resourceField.type.includes('array')) {
|
|
set(config, ck, []);
|
|
} else if (resourceField.type.includes('map')) {
|
|
set(config, ck, {});
|
|
} else if (resourceField.type.includes('boolean')) {
|
|
if (resourceField.default) {
|
|
set(config, ck, resourceField.default);
|
|
} else {
|
|
if ( !isEmpty(get(DEFAULT_EKS_CONFIG, ck)) || !isEmpty(get(DEFAULT_NODE_GROUP_CONFIG, ck)) ) {
|
|
let match = isEmpty(get(DEFAULT_EKS_CONFIG, ck)) ? get(DEFAULT_NODE_GROUP_CONFIG, ck) : get(DEFAULT_EKS_CONFIG, ck);
|
|
|
|
set(config, ck, match);
|
|
}
|
|
// we shouldn't get here, there are not that many fields in EKS and I've set the defaults for bools that are there
|
|
// but if we do hit this branch my some magic case imo a bool isn't something we can default cause its unknown...just dont do anything.
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
return config;
|
|
}
|
|
},
|
|
|
|
diffEksUpstream(lhs, rhs) {
|
|
// this is NOT a generic object diff.
|
|
// It tries to be as generic as possible but it does make certain assumptions regarding nulls and emtpy arrays/objects
|
|
// if LHS (upstream) is null and RHS (eks config) is empty we do not count this as a change
|
|
// additionally null values on the RHS will be ignored as null cant be sent in this case
|
|
const delta = {};
|
|
const rhsKeys = Object.keys(rhs);
|
|
|
|
rhsKeys.forEach((k) => {
|
|
if (k === 'type') {
|
|
return;
|
|
}
|
|
|
|
const lhsMatch = get(lhs, k);
|
|
const rhsMatch = get(rhs, k);
|
|
|
|
try {
|
|
if (isEqual(JSON.stringify(lhsMatch), JSON.stringify(rhsMatch))) {
|
|
return;
|
|
}
|
|
} catch (e){}
|
|
|
|
if (k === 'nodeGroups' || k === 'tags') {
|
|
if (!isEmpty(rhsMatch)) {
|
|
// node groups need ALL data so short circut and send it all
|
|
set(delta, k, rhsMatch);
|
|
} else {
|
|
// all node groups were deleted
|
|
set(delta, k, []);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (isEmpty(lhsMatch) || this.isEmptyObject(lhsMatch)) {
|
|
if (isEmpty(rhsMatch) || this.isEmptyObject(rhsMatch)) {
|
|
if (lhsMatch !== null && (isArray(rhsMatch) || this.isObject(rhsMatch))) {
|
|
// Empty Arrays and Empty Maps must be sent as such unless the upstream value is null, then the empty array or obj is just a init value from ember
|
|
set(delta, k, rhsMatch);
|
|
}
|
|
|
|
return;
|
|
} else {
|
|
// lhs is empty, rhs is not, just set
|
|
set(delta, k, rhsMatch);
|
|
}
|
|
} else {
|
|
if (rhsMatch !== null) {
|
|
// entry in og obj
|
|
if (isArray(lhsMatch)) {
|
|
if (isArray(rhsMatch)) {
|
|
if (!isEmpty(rhsMatch) && rhsMatch.every((m) => this.isObject(m))) {
|
|
// You have more diffing to do
|
|
rhsMatch.forEach((match) => {
|
|
// our most likely candiate for a match is node group name, but lets check the others just incase.
|
|
const matchId = get(match, 'name') || get(match, 'id') || false;
|
|
|
|
if (matchId) {
|
|
let lmatchIdx;
|
|
|
|
// we have soime kind of identifier to find a match in the upstream, so we can diff and insert to new array
|
|
const lMatch = lhsMatch.find((l, idx) => {
|
|
const lmatchId = get(l, 'name') || get(l, 'id');
|
|
|
|
if (lmatchId === matchId) {
|
|
lmatchIdx = idx;
|
|
|
|
return l;
|
|
}
|
|
});
|
|
|
|
if (lMatch) {
|
|
// we have a match in the upstream, meaning we've probably made updates to the object itself
|
|
const diffedMatch = this.diffEksUpstream(lMatch, match);
|
|
|
|
if (!isArray(get(delta, k))) {
|
|
set(delta, k, [diffedMatch]);
|
|
} else {
|
|
// diff and push into new array
|
|
delta[k].insertAt(lmatchIdx, diffedMatch);
|
|
}
|
|
} else {
|
|
// no match in upstream, new entry
|
|
if (!isArray(get(delta, k))) {
|
|
set(delta, k, [match]);
|
|
} else {
|
|
delta[k].pushObject(match);
|
|
}
|
|
}
|
|
} else {
|
|
// no match id, all we can do is dumb add
|
|
if (!isArray(get(delta, k))) {
|
|
set(delta, k, [match]);
|
|
} else {
|
|
delta[k].pushObject(match);
|
|
}
|
|
}
|
|
})
|
|
} else {
|
|
set(delta, k, rhsMatch);
|
|
}
|
|
} else {
|
|
set(delta, k, rhsMatch);
|
|
}
|
|
} else if (this.isObject(lhsMatch)) {
|
|
if (!isEmpty(rhsMatch) && !this.isEmptyObject(rhsMatch)) {
|
|
if ((Object.keys(lhsMatch) || []).length > 0) {
|
|
// You have more diffing to do
|
|
set(delta, k, this.diffEksUpstream(lhsMatch, rhsMatch));
|
|
} else if (this.isEmptyObject(lhsMatch)) {
|
|
// we had a map now we have an empty map
|
|
set(delta, k, {});
|
|
}
|
|
}
|
|
} else { // lhsMatch not an array or object
|
|
set(delta, k, rhsMatch);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
return delta;
|
|
},
|
|
|
|
/**
|
|
* True if obj is a plain object, an instantiated function/class
|
|
* @param {anything} obj
|
|
*/
|
|
isObject(obj) {
|
|
return obj // Eliminates null/undefined
|
|
&& obj instanceof Object // Eliminates primitives
|
|
&& typeof obj === 'object' // Eliminates class definitions/functions
|
|
&& !Array.isArray(obj); // Eliminates arrays
|
|
},
|
|
|
|
isEmptyObject(obj) {
|
|
return this.isObject(obj) && Object.keys(obj).length === 0;
|
|
}
|
|
|
|
});
|