hendrik/lens
1
0
Fork 0
mirror of https://github.com/lensapp/lens.git synced 2025-05-20 05:10:56 +00:00
Code Issues Projects Releases Wiki Activity

Add context menu entry for deleting local clusters

Browse Source 
- Use bundled kubectl, private, and SemVer

- Hide details page after deleting cluster

- Add status deleting to KubernetesClusters

- Push catalog on leading edge, observe the set directly

- Mark deleting entities as disabled

- Remove hotbar items when deleting an entity

Signed-off-by: Sebastian Malton <sebastian@malton.name>
This commit is contained in:
Sebastian Malton 2021-05-31 16:41:22 -04:00
parent a88b9c675e
commit 685fd971a7
28 changed files with 250 additions and 292 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
src/common/__tests__/cluster-store.test.ts
View File

@ -125,33 +125,28 @@ describe("empty config", () => {
expect(storedCluster.preferences.terminalCWD).toBe("/tmp");
expect(storedCluster.preferences.icon).toBe("data:image/jpeg;base64, iVBORw0KGgoAAAANSUhEUgAAA1wAAAKoCAYAAABjkf5");
});
it("removes cluster from store", async () => {
await ClusterStore.getInstance().removeById("foo");
expect(ClusterStore.getInstance().getById("foo")).toBeNull();
});
});
describe("with prod and dev clusters added", () => {
beforeEach(() => {
ClusterStore.getInstance().addClusters(
new Cluster({
id: "prod",
contextName: "foo",
preferences: {
clusterName: "prod"
},
kubeConfigPath: embed("prod", kubeconfig)
}),
new Cluster({
id: "dev",
contextName: "foo2",
preferences: {
clusterName: "dev"
},
kubeConfigPath: embed("dev", kubeconfig)
})
);
const store = ClusterStore.getInstance();
store.addCluster({
id: "prod",
contextName: "foo",
preferences: {
clusterName: "prod"
},
kubeConfigPath: embed("prod", kubeconfig)
});
store.addCluster({
id: "dev",
contextName: "foo2",
preferences: {
clusterName: "dev"
},
kubeConfigPath: embed("dev", kubeconfig)
});
});
it("check if store can contain multiple clusters", () => {
@ -222,16 +217,6 @@ describe("config with existing clusters", () => {
expect(storedCluster.preferences.terminalCWD).toBe("/foo");
});
it("allows to delete a cluster", () => {
ClusterStore.getInstance().removeById("cluster2");
const storedCluster = ClusterStore.getInstance().getById("cluster1");
expect(storedCluster).toBeTruthy();
const storedCluster2 = ClusterStore.getInstance().getById("cluster2");
expect(storedCluster2).toBeNull();
});
it("allows getting all of the clusters", async () => {
const storedClusters = ClusterStore.getInstance().clustersList;

50
src/common/catalog-entities/kubernetes-cluster.ts
View File

@ -21,13 +21,13 @@
import { catalogCategoryRegistry } from "../catalog/catalog-category-registry";
import { CatalogEntity, CatalogEntityActionContext, CatalogEntityAddMenuContext, CatalogEntityContextMenuContext, CatalogEntityMetadata, CatalogEntityStatus } from "../catalog";
import { clusterActivateHandler, clusterDisconnectHandler } from "../cluster-ipc";
import { clusterActivateHandler, clusterDeleteHandler, clusterDisconnectHandler } from "../cluster-ipc";
import { ClusterStore } from "../cluster-store";
import { requestMain } from "../ipc";
import { productName } from "../vars";
import { CatalogCategory, CatalogCategorySpec } from "../catalog";
import { addClusterURL } from "../routes";
import { app } from "electron";
import { HotbarStore } from "../hotbar-store";
export type KubernetesClusterPrometheusMetrics = {
address?: {
@ -50,7 +50,7 @@ export type KubernetesClusterSpec = {
};
export interface KubernetesClusterStatus extends CatalogEntityStatus {
phase: "connected" | "disconnected";
phase: "connected" | "disconnected" | "deleting";
}
export class KubernetesCluster extends CatalogEntity<CatalogEntityMetadata, KubernetesClusterStatus, KubernetesClusterSpec> {
@ -103,39 +103,39 @@ export class KubernetesCluster extends CatalogEntity<CatalogEntityMetadata, Kube
async onContextMenuOpen(context: CatalogEntityContextMenuContext) {
if (!this.metadata.source || this.metadata.source === "local") {
context.menuItems.push({
title: "Settings",
icon: "edit",
onClick: async () => context.navigate(`/entity/${this.metadata.uid}/settings`)
});
}
if (this.metadata.labels["file"]?.startsWith(ClusterStore.storedKubeConfigFolder)) {
context.menuItems.push({
title: "Delete",
icon: "delete",
onClick: async () => ClusterStore.getInstance().removeById(this.metadata.uid),
confirm: {
message: `Remove Kubernetes Cluster "${this.metadata.name} from ${productName}?`
}
});
context.menuItems.push(
{
title: "Settings",
icon: "edit",
onClick: () => context.navigate(`/entity/${this.metadata.uid}/settings`)
},
{
title: "Delete",
icon: "delete",
onClick: () => {
HotbarStore.getInstance().removeAllHotbarItems(this.getId());
context.hideDetails();
requestMain(clusterDeleteHandler, this.metadata.uid);
},
confirm: {
// TODO: change this to be a <p> tag with better formatting once this code can accept it.
message: `Delete the "${this.metadata.name}" context from "${this.metadata.labels.file}"?`
}
},
);
}
if (this.status.phase == "connected") {
context.menuItems.push({
title: "Disconnect",
icon: "link_off",
onClick: async () => {
requestMain(clusterDisconnectHandler, this.metadata.uid);
}
onClick: () => requestMain(clusterDisconnectHandler, this.metadata.uid)
});
} else {
context.menuItems.push({
title: "Connect",
icon: "link",
onClick: async () => {
context.navigate(`/cluster/${this.metadata.uid}`);
}
onClick: () => context.navigate(`/cluster/${this.metadata.uid}`)
});
}

6
src/common/catalog/catalog-entity.ts
View File

@ -86,6 +86,11 @@ export interface CatalogEntityMetadata {
export interface CatalogEntityStatus {
phase: string;
reason?: string;
/**
* @default true
*/
enabled?: boolean;
message?: string;
active?: boolean;
}
@ -130,6 +135,7 @@ export interface CatalogEntitySettingsMenu {
export interface CatalogEntityContextMenuContext {
navigate: (url: string) => void;
hideDetails: () => void;
menuItems: CatalogEntityContextMenu[];
}

1
src/common/cluster-ipc.ts
View File

@ -24,5 +24,6 @@ export const clusterSetFrameIdHandler = "cluster:set-frame-id";
export const clusterVisibilityHandler = "cluster:visibility";
export const clusterRefreshHandler = "cluster:refresh";
export const clusterDisconnectHandler = "cluster:disconnect";
export const clusterDeleteHandler = "cluster:delete";
export const clusterKubectlApplyAllHandler = "cluster:kubectl-apply-all";
export const clusterKubectlDeleteAllHandler = "cluster:kubectl-delete-all";

79
src/common/cluster-store.ts
View File

@ -20,8 +20,7 @@
*/
import path from "path";
import { app, ipcMain, ipcRenderer, remote, webFrame } from "electron";
import { unlink } from "fs-extra";
import { app, ipcMain, ipcRenderer, webFrame } from "electron";
import { action, comparer, computed, makeObservable, observable, reaction } from "mobx";
import { BaseStore } from "./base-store";
import { Cluster, ClusterState } from "../main/cluster";
@ -30,7 +29,7 @@ import * as uuid from "uuid";
import logger from "../main/logger";
import { appEventBus } from "./event-bus";
import { ipcMainHandle, ipcMainOn, ipcRendererOn, requestMain } from "./ipc";
import { disposer, noop, toJS } from "./utils";
import { disposer, toJS } from "./utils";
export interface ClusterIconUpload {
clusterId: string;
@ -83,9 +82,6 @@ export interface ClusterModel {
/** List of accessible namespaces */
accessibleNamespaces?: string[];
/** @deprecated */
kubeConfig?: string; // yaml
}
export interface ClusterPreferences extends ClusterPrometheusPreferences {
@ -113,7 +109,7 @@ export class ClusterStore extends BaseStore<ClusterStoreModel> {
private static StateChannel = "cluster:state";
static get storedKubeConfigFolder(): string {
return path.resolve((app || remote.app).getPath("userData"), "kubeconfigs");
return path.resolve(app.getPath("userData"), "kubeconfigs");
}
static getCustomKubeConfigPath(clusterId: ClusterId = uuid.v4()): string {
@ -123,7 +119,6 @@ export class ClusterStore extends BaseStore<ClusterStoreModel> {
@observable clusters = observable.map<ClusterId, Cluster>();
@observable removedClusters = observable.map<ClusterId, Cluster>();
private static stateRequestChannel = "cluster:states";
protected disposer = disposer();
constructor() {
@ -142,35 +137,22 @@ export class ClusterStore extends BaseStore<ClusterStoreModel> {
}
async load() {
const initialStates = "cluster:states";
await super.load();
type clusterStateSync = {
id: string;
state: ClusterState;
};
if (ipcRenderer) {
logger.info("[CLUSTER-STORE] requesting initial state sync");
const clusterStates: clusterStateSync[] = await requestMain(ClusterStore.stateRequestChannel);
clusterStates.forEach((clusterState) => {
const cluster = this.getById(clusterState.id);
if (cluster) {
cluster.setState(clusterState.state);
}
});
for (const { id, state } of await requestMain(initialStates)) {
this.getById(id)?.setState(state);
}
} else if (ipcMain) {
ipcMainHandle(ClusterStore.stateRequestChannel, (): clusterStateSync[] => {
const clusterStates: clusterStateSync[] = [];
this.clustersList.forEach((cluster) => {
clusterStates.push({
state: cluster.getState(),
id: cluster.id
});
});
return clusterStates;
ipcMainHandle(initialStates, () => {
return this.clustersList.map(cluster => ({
id: cluster.id,
state: cluster.getState(),
}));
});
}
}
@ -178,9 +160,7 @@ export class ClusterStore extends BaseStore<ClusterStoreModel> {
protected pushStateToViewsAutomatically() {
if (ipcMain) {
this.disposer.push(
reaction(() => this.connectedClustersList, () => {
this.pushState();
}),
reaction(() => this.connectedClustersList, () => this.pushState()),
);
}
}
@ -229,18 +209,6 @@ export class ClusterStore extends BaseStore<ClusterStoreModel> {
return this.clusters.get(id) ?? null;
}
@action
addClusters(...models: ClusterModel[]): Cluster[] {
const clusters: Cluster[] = [];
models.forEach(model => {
clusters.push(this.addCluster(model));
});
return clusters;
}
@action
addCluster(clusterOrModel: ClusterModel | Cluster): Cluster {
appEventBus.emit({ name: "cluster", action: "add" });
@ -253,25 +221,6 @@ export class ClusterStore extends BaseStore<ClusterStoreModel> {
return cluster;
}
async removeCluster(model: ClusterModel) {
await this.removeById(model.id);
}
@action
async removeById(clusterId: ClusterId) {
appEventBus.emit({ name: "cluster", action: "remove" });
const cluster = this.getById(clusterId);
if (cluster) {
this.clusters.delete(clusterId);
// remove only custom kubeconfigs (pasted as text)
if (cluster.kubeConfigPath == ClusterStore.getCustomKubeConfigPath(clusterId)) {
await unlink(cluster.kubeConfigPath).catch(noop);
}
}
}
@action
protected fromStore({ clusters = [] }: ClusterStoreModel = {}) {
const currentClusters = new Map(this.clusters);

21
src/common/hotbar-store.ts
View File

@ -181,7 +181,7 @@ export class HotbarStore extends BaseStore<HotbarStoreModel> {
}
@action
removeFromHotbar(uid: string) {
removeFromHotbar(uid: string): void {
const hotbar = this.getActive();
const index = hotbar.items.findIndex((i) => i?.entity.uid === uid);
@ -192,6 +192,25 @@ export class HotbarStore extends BaseStore<HotbarStoreModel> {
hotbar.items[index] = null;
}
/**
* Remvove all hotbar items that reference the `uid`.
* @param uid The `EntityId` that each hotbar item refers to
* @returns A function that will (in an action) undo the removing of the hotbar items. This function will not complete if the hotbar has changed.
*/
@action
removeAllHotbarItems(uid: string) {
const undoItems: [Hotbar, number, HotbarItem][] = [];
for (const hotbar of this.hotbars) {
const index = hotbar.items.findIndex((i) => i?.entity.uid === uid);
if (index >= 0) {
undoItems.push([hotbar, index, hotbar.items[index]]);
hotbar.items[index] = null;
}
}
}
findClosestEmptyIndex(from: number, direction = 1) {
let index = from;

5
src/common/utils/index.ts
View File

@ -19,8 +19,9 @@
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
// Common utils (main OR renderer)
/**
* A function that does nothing
*/
export function noop<T extends any[]>(...args: T): void {
return void args;
}

4
src/main/__test__/cluster.test.ts
View File

@ -120,8 +120,8 @@ describe("create clusters", () => {
protected bindEvents() {
return;
}
protected async ensureKubectl() {
return Promise.resolve(true);
async ensureKubectl() {
return Promise.resolve(null);
}
}({
id: "foo",

2
src/main/catalog-pusher.ts
View File

@ -30,7 +30,7 @@ import type { CatalogEntity } from "../common/catalog";
const broadcaster = debounce((items: CatalogEntity[]) => {
broadcastMessage("catalog:items", items);
}, 1_000, { trailing: true });
}, 1_000, { leading: true, trailing: true });
export function pushCatalogToRenderer(catalog: CatalogEntityRegistry) {
return reaction(() => toJS(catalog.items), (items) => {

4
src/main/catalog-sources/__test__/kubeconfig-sync.test.ts
View File

@ -27,6 +27,7 @@ import { computeDiff, configToModels } from "../kubeconfig-sync";
import mockFs from "mock-fs";
import fs from "fs";
import { ClusterStore } from "../../../common/cluster-store";
import { ClusterManager } from "../../cluster-manager";
jest.mock("electron", () => ({
app: {
@ -38,10 +39,13 @@ describe("kubeconfig-sync.source tests", () => {
beforeEach(() => {
mockFs();
ClusterStore.createInstance();
ClusterManager.createInstance();
});
afterEach(() => {
mockFs.restore();
ClusterStore.resetInstance();
ClusterManager.resetInstance();
});
describe("configsToModels", () => {

5
src/main/catalog-sources/kubeconfig-sync.ts
View File

@ -31,7 +31,7 @@ import logger from "../logger";
import type { KubeConfig } from "@kubernetes/client-node";
import { loadConfigFromString, splitConfig } from "../../common/kube-helpers";
import { Cluster } from "../cluster";
import { catalogEntityFromCluster } from "../cluster-manager";
import { catalogEntityFromCluster, ClusterManager } from "../cluster-manager";
import { UserStore } from "../../common/user-store";
import { ClusterStore, UpdateClusterModel } from "../../common/cluster-store";
import { createHash } from "crypto";
@ -170,6 +170,9 @@ export function computeDiff(contents: string, source: RootSource, filePath: stri
// remove and disconnect clusters that were removed from the config
if (!model) {
// remove from the deleting set, so that if a new context of the same name is added, it isn't marked as deleting
ClusterManager.getInstance().deleting.delete(value[0].id);
value[0].disconnect();
source.delete(contextName);
logger.debug(`${logPrefix} Removed old cluster from sync`, { filePath, contextName });

25
src/main/cluster-manager.ts
View File

@ -21,8 +21,8 @@
import "../common/cluster-ipc";
import type http from "http";
import { action, autorun, makeObservable, reaction, toJS } from "mobx";
import { ClusterStore, getClusterIdFromHost } from "../common/cluster-store";
import { action, autorun, makeObservable, observable, observe, reaction, toJS } from "mobx";
import { ClusterId, ClusterStore, getClusterIdFromHost } from "../common/cluster-store";
import type { Cluster } from "./cluster";
import logger from "./logger";
import { apiKubePrefix } from "../common/vars";
@ -30,17 +30,18 @@ import { Singleton } from "../common/utils";
import { catalogEntityRegistry } from "./catalog";
import { KubernetesCluster, KubernetesClusterPrometheusMetrics } from "../common/catalog-entities/kubernetes-cluster";
import { ipcMainOn } from "../common/ipc";
import { once } from "lodash";
export class ClusterManager extends Singleton {
private store = ClusterStore.getInstance();
deleting = observable.set<ClusterId>();
constructor() {
super();
makeObservable(this);
this.bindEvents();
}
private bindEvents() {
init = once(() => {
// reacting to every cluster's state change and total amount of items
reaction(
() => this.store.clustersList.map(c => c.getState()),
@ -59,6 +60,12 @@ export class ClusterManager extends Singleton {
this.syncClustersFromCatalog(entities);
});
observe(this.deleting, change => {
if (change.type === "add") {
catalogEntityRegistry.getById(change.newValue).status.phase = "deleting";
}
});
// auto-stop removed clusters
autorun(() => {
const removedClusters = Array.from(this.store.removedClusters.values());
@ -76,7 +83,7 @@ export class ClusterManager extends Singleton {
ipcMainOn("network:offline", this.onNetworkOffline);
ipcMainOn("network:online", this.onNetworkOnline);
}
});
@action
protected updateCatalog(clusters: Cluster[]) {
@ -116,7 +123,13 @@ export class ClusterManager extends Singleton {
}
protected updateEntityStatus(entity: KubernetesCluster, cluster: Cluster) {
entity.status.phase = cluster.accessible ? "connected" : "disconnected";
if (this.deleting.has(entity.getId())) {
entity.status.phase = "deleting";
entity.status.enabled = false;
} else {
entity.status.phase = cluster.accessible ? "connected" : "disconnected";
entity.status.enabled = true;
}
}
@action syncClustersFromCatalog(entities: KubernetesCluster[]) {

19
src/main/cluster.ts
View File

@ -88,12 +88,7 @@ export interface ClusterState {
export class Cluster implements ClusterModel, ClusterState {
/** Unique id for a cluster */
public readonly id: ClusterId;
/**
* Kubectl
*
* @internal
*/
public kubeCtl: Kubectl;
private kubeCtl: Kubectl;
/**
* Context handler
*
@ -363,7 +358,7 @@ export class Cluster implements ClusterModel, ClusterState {
if (this.accessible) {
await this.refreshAccessibility();
this.ensureKubectl();
this.ensureKubectl(); // download kubectl in background, so it's not blocking dashboard
}
this.activated = true;
@ -373,10 +368,12 @@ export class Cluster implements ClusterModel, ClusterState {
/**
* @internal
*/
protected async ensureKubectl() {
this.kubeCtl = new Kubectl(this.version);
async ensureKubectl() {
this.kubeCtl ??= new Kubectl(this.version);
return this.kubeCtl.ensureKubectl(); // download kubectl in background, so it's not blocking dashboard
await this.kubeCtl.ensureKubectl();
return this.kubeCtl;
}
/**
@ -650,7 +647,7 @@ export class Cluster implements ClusterModel, ClusterState {
const api = (await this.getProxyKubeconfig()).makeApiClient(CoreV1Api);
try {
const { body: { items }} = await api.listNamespace();
const { body: { items } } = await api.listNamespace();
const namespaces = items.map(ns => ns.metadata.name);
this.getAllowedNamespacesErrorCount = 0; // reset on success

5
src/main/helm/helm-release-manager.ts
View File

@ -169,9 +169,10 @@ export async function rollback(name: string, namespace: string, revision: number
async function getResources(name: string, namespace: string, cluster: Cluster) {
try {
const helm = await helmCli.binaryPath();
const kubectl = await cluster.kubeCtl.getPath();
const kubectl = await cluster.ensureKubectl();
const kubectlPath = await kubectl.getPath();
const pathToKubeconfig = await cluster.getProxyKubeconfigPath();
const { stdout } = await promiseExec(`"${helm}" get manifest ${name} --namespace ${namespace} --kubeconfig ${pathToKubeconfig} | "${kubectl}" get -n ${namespace} --kubeconfig ${pathToKubeconfig} -f - -o=json`);
const { stdout } = await promiseExec(`"${helm}" get manifest ${name} --namespace ${namespace} --kubeconfig ${pathToKubeconfig} | "${kubectlPath}" get -n ${namespace} --kubeconfig ${pathToKubeconfig} -f - -o=json`);
return JSON.parse(stdout).items;
} catch {

2
src/main/index.ts
View File

@ -148,7 +148,7 @@ app.on("ready", async () => {
const lensProxy = LensProxy.createInstance(handleWsUpgrade);
ClusterManager.createInstance();
ClusterManager.createInstance().init();
KubeconfigSyncManager.createInstance();
try {

29
src/main/initializers/ipc.ts
View File

@ -22,11 +22,15 @@
import type { IpcMainInvokeEvent } from "electron";
import type { KubernetesCluster } from "../../common/catalog-entities";
import { clusterFrameMap } from "../../common/cluster-frames";
import { clusterActivateHandler, clusterSetFrameIdHandler, clusterVisibilityHandler, clusterRefreshHandler, clusterDisconnectHandler, clusterKubectlApplyAllHandler, clusterKubectlDeleteAllHandler } from "../../common/cluster-ipc";
import { clusterActivateHandler, clusterSetFrameIdHandler, clusterVisibilityHandler, clusterRefreshHandler, clusterDisconnectHandler, clusterKubectlApplyAllHandler, clusterKubectlDeleteAllHandler, clusterDeleteHandler } from "../../common/cluster-ipc";
import { ClusterId, ClusterStore } from "../../common/cluster-store";
import { appEventBus } from "../../common/event-bus";
import { ipcMainHandle } from "../../common/ipc";
import { catalogEntityRegistry } from "../catalog";
import { ClusterManager } from "../cluster-manager";
import { bundledKubectlPath } from "../kubectl";
import logger from "../logger";
import { promiseExecFile } from "../promise-exec";
import { ResourceApplier } from "../resource-applier";
export function initIpcMainHandlers() {
@ -73,6 +77,29 @@ export function initIpcMainHandlers() {
}
});
ipcMainHandle(clusterDeleteHandler, async (event, clusterId: ClusterId) => {
appEventBus.emit({ name: "cluster", action: "remove" });
const cluster = ClusterStore.getInstance().getById(clusterId);
if (!cluster) {
return;
}
ClusterManager.getInstance().deleting.add(clusterId);
cluster.disconnect();
clusterFrameMap.delete(cluster.id);
const kubectlPath = bundledKubectlPath();
const args = ["config", "delete-context", cluster.contextName, "--kubeconfig", cluster.kubeConfigPath];
try {
await promiseExecFile(kubectlPath, args);
} catch ({ stderr }) {
logger.error(`[CLUSTER-REMOVE]: failed to remove cluster: ${stderr}`, { clusterId, context: cluster.contextName });
throw `Failed to remove cluster: ${stderr}`;
}
});
ipcMainHandle(clusterKubectlApplyAllHandler, async (event, clusterId: ClusterId, resources: string[], extraArgs: string[]) => {
appEventBus.emit({ name: "cluster", action: "kubectl-apply-all" });
const cluster = ClusterStore.getInstance().getById(clusterId);

18
src/main/kubectl.ts
View File

@ -31,6 +31,7 @@ import { UserStore } from "../common/user-store";
import { customRequest } from "../common/request";
import { getBundledKubectlVersion } from "../common/utils/app-version";
import { isDevelopment, isWindows, isTestEnv } from "../common/vars";
import { SemVer } from "semver";
const bundledVersion = getBundledKubectlVersion();
const kubectlMap: Map<string, string> = new Map([
@ -92,14 +93,19 @@ export class Kubectl {
// Returns the single bundled Kubectl instance
public static bundled() {
if (!Kubectl.bundledInstance) Kubectl.bundledInstance = new Kubectl(Kubectl.bundledKubectlVersion);
return Kubectl.bundledInstance;
return Kubectl.bundledInstance ??= new Kubectl(Kubectl.bundledKubectlVersion);
}
constructor(clusterVersion: string) {
const versionParts = /^v?(\d+\.\d+)(.*)/.exec(clusterVersion);
const minorVersion = versionParts[1];
let version: SemVer;
try {
version = new SemVer(clusterVersion, { includePrerelease: false });
} catch {
version = new SemVer(Kubectl.bundledKubectlVersion);
}
const minorVersion = `${version.major}.${version.minor}`;
/* minorVersion is the first two digits of kube server version
if the version map includes that, use that version, if not, fallback to the exact x.y.z of kube version */
@ -107,7 +113,7 @@ export class Kubectl {
this.kubectlVersion = kubectlMap.get(minorVersion);
logger.debug(`Set kubectl version ${this.kubectlVersion} for cluster version ${clusterVersion} using version map`);
} else {
this.kubectlVersion = versionParts[1] + versionParts[2];
this.kubectlVersion = version.format();
logger.debug(`Set kubectl version ${this.kubectlVersion} for cluster version ${clusterVersion} using fallback`);
}

3
src/main/promise-exec.ts
View File

@ -20,6 +20,7 @@
*/
import * as util from "util";
import { exec } from "child_process";
import { exec, execFile } from "child_process";
export const promiseExec = util.promisify(exec);
export const promiseExecFile = util.promisify(execFile);

14
src/main/resource-applier.ts
View File

@ -36,15 +36,15 @@ export class ResourceApplier {
async apply(resource: KubernetesObject | any): Promise<string> {
resource = this.sanitizeObject(resource);
appEventBus.emit({name: "resource", action: "apply"});
appEventBus.emit({ name: "resource", action: "apply" });
return await this.kubectlApply(yaml.safeDump(resource));
}
protected async kubectlApply(content: string): Promise<string> {
const { kubeCtl } = this.cluster;
const kubectlPath = await kubeCtl.getPath();
const proxyKubeconfigPath = await this.cluster.getProxyKubeconfigPath();
const kubectl = await this.cluster.ensureKubectl();
const kubectlPath = await kubectl.getPath();
const proxyKubeconfigPath = await this.cluster.getProxyKubeconfigPath();
return new Promise<string>((resolve, reject) => {
const fileName = tempy.file({ name: "resource.yaml" });
@ -82,9 +82,9 @@ export class ResourceApplier {
}
protected async kubectlCmdAll(subCmd: string, resources: string[], args: string[] = []): Promise<string> {
const { kubeCtl } = this.cluster;
const kubectlPath = await kubeCtl.getPath();
const proxyKubeconfigPath = await this.cluster.getProxyKubeconfigPath();
const kubectl = await this.cluster.ensureKubectl();
const kubectlPath = await kubectl.getPath();
const proxyKubeconfigPath = await this.cluster.getProxyKubeconfigPath();
return new Promise((resolve, reject) => {
const tmpDir = tempy.directory();

93
src/migrations/cluster-store/3.6.0-beta.1.ts
View File

@ -23,69 +23,68 @@
// convert file path cluster icons to their base64 encoded versions
import path from "path";
import { app, remote } from "electron";
import { app } from "electron";
import { migration } from "../migration-wrapper";
import fse from "fs-extra";
import { ClusterModel, ClusterStore } from "../../common/cluster-store";
import { loadConfigFromFileSync } from "../../common/kube-helpers";
interface Pre360ClusterModel extends ClusterModel {
kubeConfig: string;
}
export default migration({
version: "3.6.0-beta.1",
run(store, printLog) {
const userDataPath = (app || remote.app).getPath("userData");
const kubeConfigBase = ClusterStore.getCustomKubeConfigPath("");
const storedClusters: ClusterModel[] = store.get("clusters") || [];
const userDataPath = app.getPath("userData");
const storedClusters: Pre360ClusterModel[] = store.get("clusters") ?? [];
const migratedClusters: ClusterModel[] = [];
if (!storedClusters.length) return;
fse.ensureDirSync(kubeConfigBase);
fse.ensureDirSync(ClusterStore.storedKubeConfigFolder);
printLog("Number of clusters to migrate: ", storedClusters.length);
const migratedClusters = storedClusters
.map(cluster => {
/**
* migrate kubeconfig
*/
try {
const absPath = ClusterStore.getCustomKubeConfigPath(cluster.id);
fse.ensureDirSync(path.dirname(absPath));
fse.writeFileSync(absPath, cluster.kubeConfig, { encoding: "utf-8", mode: 0o600 });
// take the embedded kubeconfig and dump it into a file
cluster.kubeConfigPath = absPath;
cluster.contextName = loadConfigFromFileSync(cluster.kubeConfigPath).config.getCurrentContext();
delete cluster.kubeConfig;
for (const clusterModel of storedClusters) {
/**
* migrate kubeconfig
*/
try {
const absPath = ClusterStore.getCustomKubeConfigPath(clusterModel.id);
} catch (error) {
printLog(`Failed to migrate Kubeconfig for cluster "${cluster.id}", removing cluster...`, error);
// take the embedded kubeconfig and dump it into a file
fse.writeFileSync(absPath, clusterModel.kubeConfig, { encoding: "utf-8", mode: 0o600 });
return undefined;
clusterModel.kubeConfigPath = absPath;
clusterModel.contextName = loadConfigFromFileSync(clusterModel.kubeConfigPath).config.getCurrentContext();
delete clusterModel.kubeConfig;
} catch (error) {
printLog(`Failed to migrate Kubeconfig for cluster "${clusterModel.id}", removing clusterModel...`, error);
continue;
}
/**
* migrate cluster icon
*/
try {
if (clusterModel.preferences?.icon) {
printLog(`migrating ${clusterModel.preferences.icon} for ${clusterModel.preferences.clusterName}`);
const iconPath = clusterModel.preferences.icon.replace("store://", "");
const fileData = fse.readFileSync(path.join(userDataPath, iconPath));
clusterModel.preferences.icon = `data:;base64,${fileData.toString("base64")}`;
} else {
delete clusterModel.preferences?.icon;
}
} catch (error) {
printLog(`Failed to migrate cluster icon for cluster "${clusterModel.id}"`, error);
delete clusterModel.preferences.icon;
}
/**
* migrate cluster icon
*/
try {
if (cluster.preferences?.icon) {
printLog(`migrating ${cluster.preferences.icon} for ${cluster.preferences.clusterName}`);
const iconPath = cluster.preferences.icon.replace("store://", "");
const fileData = fse.readFileSync(path.join(userDataPath, iconPath));
cluster.preferences.icon = `data:;base64,${fileData.toString("base64")}`;
} else {
delete cluster.preferences?.icon;
}
} catch (error) {
printLog(`Failed to migrate cluster icon for cluster "${cluster.id}"`, error);
delete cluster.preferences.icon;
}
return cluster;
})
.filter(c => c);
// "overwrite" the cluster configs
if (migratedClusters.length > 0) {
store.set("clusters", migratedClusters);
migratedClusters.push(clusterModel);
}
store.set("clusters", migratedClusters);
}
});

2
src/renderer/components/+catalog/catalog-entity-details.tsx
View File

@ -120,7 +120,7 @@ export class CatalogEntityDetails extends Component<Props> {
usePortal={true}
open={true}
title={title}
toolbar={<CatalogEntityDrawerMenu entity={entity} key={entity.getId()} />}
toolbar={<CatalogEntityDrawerMenu entity={entity} key={entity.getId()} hideDrawer={hideDetails} />}
onClose={hideDetails}
>
{this.renderContent()}

4
src/renderer/components/+catalog/catalog-entity-drawer-menu.tsx
View File

@ -33,6 +33,7 @@ import { Icon } from "../icon";
export interface CatalogEntityDrawerMenuProps<T extends CatalogEntity> extends MenuActionsProps {
entity: T | null | undefined;
hideDrawer: () => void,
}
@observer
@ -47,7 +48,8 @@ export class CatalogEntityDrawerMenu<T extends CatalogEntity> extends React.Comp
componentDidMount() {
this.contextMenu = {
menuItems: [],
navigate: (url: string) => navigate(url)
navigate: (url: string) => navigate(url),
hideDetails: this.props.hideDrawer,
};
this.props.entity?.onContextMenuOpen(this.contextMenu);
}

4
src/renderer/components/+catalog/catalog-entity.store.ts
View File

@ -52,6 +52,10 @@ export class CatalogEntityItem implements ItemObject {
return this.entity.status.phase;
}
@computed get enabled() {
return this.entity.status.enabled ?? true;
}
get labels() {
const labels: string[] = [];

2
src/renderer/components/+catalog/catalog.module.css
View File

@ -44,7 +44,7 @@
color: var(--colorSuccess);
}
.disconnected {
.disconnected, .deleting {
color: var(--halfGray);
}

17
src/renderer/components/+catalog/catalog.tsx
View File

@ -79,7 +79,8 @@ export class Catalog extends React.Component<Props> {
async componentDidMount() {
this.contextMenu = {
menuItems: observable.array([]),
navigate: (url: string) => navigate(url)
navigate: (url: string) => navigate(url),
hideDetails: () => this.selectedItem = null,
};
this.catalogEntityStore = new CatalogEntityStore();
disposeOnUnmount(this, [
@ -107,9 +108,9 @@ export class Catalog extends React.Component<Props> {
HotbarStore.getInstance().addToHotbar(item.entity);
}
onDetails(item: CatalogEntityItem) {
onDetails = (item: CatalogEntityItem) => {
this.selectedItem = item;
}
};
onMenuItemClick(menuItem: CatalogEntityContextMenu) {
if (menuItem.confirm) {
@ -202,6 +203,9 @@ export class Catalog extends React.Component<Props> {
{ title: "Labels", className: css.labelsCell },
{ title: "Status", className: css.statusCell, sortBy: sortBy.status },
]}
customizeTableRowProps={(item: CatalogEntityItem) => ({
disabled: !item.enabled,
})}
renderTableContents={(item: CatalogEntityItem) => [
this.renderIcon(item),
item.name,
@ -209,7 +213,7 @@ export class Catalog extends React.Component<Props> {
item.labels.map((label) => <Badge className={css.badge} key={label} label={label} title={label} />),
{ title: item.phase, className: cssNames(css[item.phase]) }
]}
onDetails={(item: CatalogEntityItem) => this.onDetails(item) }
onDetails={this.onDetails}
renderItemMenu={this.renderItemMenu}
/>
);
@ -240,6 +244,9 @@ export class Catalog extends React.Component<Props> {
{ title: "Labels", className: css.labelsCell },
{ title: "Status", className: css.statusCell, sortBy: sortBy.status },
]}
customizeTableRowProps={(item: CatalogEntityItem) => ({
disabled: !item.enabled,
})}
renderTableContents={(item: CatalogEntityItem) => [
this.renderIcon(item),
item.name,
@ -249,7 +256,7 @@ export class Catalog extends React.Component<Props> {
{ title: item.phase, className: cssNames(css[item.phase]) }
]}
detailsItem={this.selectedItem}
onDetails={(item: CatalogEntityItem) => this.onDetails(item) }
onDetails={this.onDetails}
renderItemMenu={this.renderItemMenu}
/>
);

5
src/renderer/components/hotbar/hotbar-entity-icon.tsx
View File

@ -27,7 +27,7 @@ import type { CatalogEntity, CatalogEntityContextMenu, CatalogEntityContextMenuC
import { catalogCategoryRegistry } from "../../api/catalog-category-registry";
import { catalogEntityRegistry } from "../../api/catalog-entity-registry";
import { navigate } from "../../navigation";
import { cssNames, IClassName } from "../../utils";
import { cssNames, IClassName, noop } from "../../utils";
import { Icon } from "../icon";
import { HotbarIcon } from "./hotbar-icon";
import { HotbarStore } from "../../../common/hotbar-store";
@ -54,7 +54,8 @@ export class HotbarEntityIcon extends React.Component<Props> {
componentDidMount() {
this.contextMenu = {
menuItems: [],
navigate: (url: string) => navigate(url)
navigate: (url: string) => navigate(url),
hideDetails: noop,
};
}

6
src/renderer/ipc/index.tsx
View File

@ -25,7 +25,6 @@ import { areArgsUpdateAvailableFromMain, UpdateAvailableChannel, onCorrect, Upda
import { Notifications, notificationsStore } from "../components/notifications";
import { Button } from "../components/button";
import { isMac } from "../../common/vars";
import { invalidKubeconfigHandler } from "./invalid-kubeconfig-handler";
import { ClusterStore } from "../../common/cluster-store";
import { navigate } from "../navigation";
import { entitySettingsURL } from "../../common/routes";
@ -87,7 +86,7 @@ function ListNamespacesForbiddenHandler(event: IpcRendererEvent, ...[clusterId]:
if (!wasDisplayed || (now - lastDisplayedAt) > intervalBetweenNotifications) {
listNamespacesForbiddenHandlerDisplayedAt.set(clusterId, now);
} else {
} else {
// don't bother the user too often
return;
}
@ -100,7 +99,7 @@ function ListNamespacesForbiddenHandler(event: IpcRendererEvent, ...[clusterId]:
<b>Add Accessible Namespaces</b>
<p>Cluster <b>{ClusterStore.getInstance().getById(clusterId).name}</b> does not have permissions to list namespaces. Please add the namespaces you have access to.</p>
<div className="flex gaps row align-left box grow">
<Button active outlined label="Go to Accessible Namespaces Settings" onClick={()=> {
<Button active outlined label="Go to Accessible Namespaces Settings" onClick={() => {
navigate(entitySettingsURL({ params: { entityId: clusterId }, fragment: "accessible-namespaces" }));
notificationsStore.remove(notificationId);
}} />
@ -120,7 +119,6 @@ export function registerIpcHandlers() {
listener: UpdateAvailableHandler,
verifier: areArgsUpdateAvailableFromMain,
});
onCorrect(invalidKubeconfigHandler);
onCorrect({
source: ipcRenderer,
channel: ClusterListNamespaceForbiddenChannel,

66
src/renderer/ipc/invalid-kubeconfig-handler.tsx
View File

@ -1,66 +0,0 @@
/**
* Copyright (c) 2021 OpenLens Authors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
* the Software, and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
import React from "react";
import { ipcRenderer, IpcRendererEvent, shell } from "electron";
import { ClusterStore } from "../../common/cluster-store";
import { InvalidKubeConfigArgs, InvalidKubeconfigChannel } from "../../common/ipc/invalid-kubeconfig";
import { Notifications, notificationsStore } from "../components/notifications";
import { Button } from "../components/button";
import { productName } from "../../common/vars";
export const invalidKubeconfigHandler = {
source: ipcRenderer,
channel: InvalidKubeconfigChannel,
listener: InvalidKubeconfigListener,
verifier: (args: [unknown]): args is InvalidKubeConfigArgs => {
return args.length === 1 && typeof args[0] === "string" && !!ClusterStore.getInstance().getById(args[0]);
},
};
function InvalidKubeconfigListener(event: IpcRendererEvent, ...[clusterId]: InvalidKubeConfigArgs): void {
const notificationId = `invalid-kubeconfig:${clusterId}`;
const cluster = ClusterStore.getInstance().getById(clusterId);
const contextName = cluster.name !== cluster.contextName ? `(context: ${cluster.contextName})` : "";
Notifications.error(
(
<div className="flex column gaps">
<b>Cluster with Invalid Kubeconfig Detected!</b>
<p>Cluster <b>{cluster.name}</b> has invalid kubeconfig {contextName} and cannot be displayed.
Please fix the <a href="#" onClick={(e) => { e.preventDefault(); shell.showItemInFolder(cluster.kubeConfigPath); }}>kubeconfig</a> manually and restart {productName}
or remove the cluster.</p>
<p>Do you want to remove the cluster now?</p>
<div className="flex gaps row align-left box grow">
<Button active outlined label="Remove" onClick={()=> {
ClusterStore.getInstance().removeById(clusterId);
notificationsStore.remove(notificationId);
}} />
<Button active outlined label="Cancel" onClick={() => notificationsStore.remove(notificationId)} />
</div>
</div>
),
{
id: notificationId,
timeout: 0
}
);
}