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

Merge branch 'master' into metrics-extraction

Browse Source
This commit is contained in:
Juho Heikka 2023-04-06 15:46:54 +03:00 committed by GitHub
commit e0040e1c1c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
116 changed files with 1089 additions and 1137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
package-lock.json generated
View File

@ -23326,9 +23326,9 @@
}
},
"node_modules/joi": {
"version": "17.8.4",
"resolved": "https://registry.npmjs.org/joi/-/joi-17.8.4.tgz",
"integrity": "sha512-jjdRHb5WtL+KgSHvOULQEPPv4kcl+ixd1ybOFQq3rWLgEEqc03QMmilodL0GVJE14U/SQDXkUhQUSZANGDH/AA==",
"version": "17.9.1",
"resolved": "https://registry.npmjs.org/joi/-/joi-17.9.1.tgz",
"integrity": "sha512-FariIi9j6QODKATGBrEX7HZcja8Bsh3rfdGYy/Sb65sGlZWK/QWesU1ghk7aJWDj95knjXlQfSmzFSPPkLVsfw==",
"dependencies": {
"@hapi/hoek": "^9.0.0",
"@hapi/topo": "^5.0.0",
@ -38180,7 +38180,7 @@
"hpagent": "^1.2.0",
"http-proxy": "^1.18.1",
"immer": "^9.0.19",
"joi": "^17.7.1",
"joi": "^17.9.1",
"js-yaml": "^4.1.0",
"lodash": "^4.17.15",
"marked": "^4.2.12",

6
package.json
View File

@ -21,13 +21,13 @@
"postdev": "lerna watch -- lerna run build --stream --scope \\$LERNA_PACKAGE_NAME",
"prestart-dev": "cd packages/open-lens && rimraf static/build/ && npm run build:tray-icons && npm run download:binaries",
"start-dev": "lerna run start",
"lint": "lerna run lint --stream",
"lint": "lerna run lint --stream --no-bail",
"lint:fix": "lerna run lint:fix --stream",
"mkdocs:serve-local": "docker build -t mkdocs-serve-local:latest mkdocs/ && docker run --rm -it -p 8000:8000 -v ${PWD}:/docs mkdocs-serve-local:latest",
"mkdocs:verify": "docker build -t mkdocs-serve-local:latest mkdocs/ && docker run --rm -v ${PWD}:/docs mkdocs-serve-local:latest build --strict",
"test:unit": "lerna run --stream test:unit",
"test:unit": "lerna run --stream test:unit --no-bail",
"test:unit:watch": "jest --watch",
"test:integration": "lerna run --stream test:integration",
"test:integration": "lerna run --stream test:integration --no-bail",
"bump-version": "lerna version --no-git-tag-version --no-push",
"precreate-release-pr": "cd packages/release-tool && npm run build",
"create-release-pr": "node packages/release-tool/dist/index.js"

39
packages/business-features/keyboard-shortcuts/src/invoke-shortcut.injectable.ts
View File

@ -1,11 +1,7 @@
import { pipeline } from "@ogre-tools/fp";
import { filter, isString } from "lodash/fp";
import { getInjectable } from "@ogre-tools/injectable";
import {
Binding,
KeyboardShortcut,
keyboardShortcutInjectionToken,
} from "./keyboard-shortcut-injection-token";
import { Binding, KeyboardShortcut, keyboardShortcutInjectionToken } from "./keyboard-shortcut-injection-token";
import platformInjectable from "./platform.injectable";
export type InvokeShortcut = (event: KeyboardEvent) => void;
@ -46,29 +42,26 @@ const toBindingWithDefaults = (binding: Binding) =>
...binding,
};
const toShortcutsWithMatchingBinding =
(event: KeyboardEvent, platform: string) => (shortcut: KeyboardShortcut) => {
const binding = toBindingWithDefaults(shortcut.binding);
const toShortcutsWithMatchingBinding = (event: KeyboardEvent, platform: string) => (shortcut: KeyboardShortcut) => {
const binding = toBindingWithDefaults(shortcut.binding);
const shiftModifierMatches = binding.shift === event.shiftKey;
const altModifierMatches = binding.altOrOption === event.altKey;
const shiftModifierMatches = binding.shift === event.shiftKey;
const altModifierMatches = binding.altOrOption === event.altKey;
const isMac = platform === "darwin";
const isMac = platform === "darwin";
const ctrlModifierMatches =
binding.ctrl === event.ctrlKey || (!isMac && binding.ctrlOrCommand === event.ctrlKey);
const ctrlModifierMatches = binding.ctrl === event.ctrlKey || (!isMac && binding.ctrlOrCommand === event.ctrlKey);
const metaModifierMatches =
binding.meta === event.metaKey || (isMac && binding.ctrlOrCommand === event.metaKey);
const metaModifierMatches = binding.meta === event.metaKey || (isMac && binding.ctrlOrCommand === event.metaKey);
return (
event.code === binding.code &&
shiftModifierMatches &&
ctrlModifierMatches &&
altModifierMatches &&
metaModifierMatches
);
};
return (
event.code === binding.code &&
shiftModifierMatches &&
ctrlModifierMatches &&
altModifierMatches &&
metaModifierMatches
);
};
const invokeShortcutInjectable = getInjectable({
id: "invoke-shortcut",

5
packages/business-features/keyboard-shortcuts/src/keyboard-shortcut-listener.tsx
View File

@ -26,10 +26,7 @@ const NonInjectedKeyboardShortcutListener = ({
return <>{children}</>;
};
export const KeyboardShortcutListener = withInjectables<
Dependencies,
KeyboardShortcutListenerProps
>(
export const KeyboardShortcutListener = withInjectables<Dependencies, KeyboardShortcutListenerProps>(
NonInjectedKeyboardShortcutListener,
{

3
packages/business-features/keyboard-shortcuts/src/keyboard-shortcuts.test.tsx
View File

@ -175,8 +175,7 @@ describe("keyboard-shortcuts", () => {
shouldCallCallback: true,
},
{
scenario:
"given shortcut with shift modifier, when shortcut is pressed, calls the callback",
scenario: "given shortcut with shift modifier, when shortcut is pressed, calls the callback",
binding: { shift: true, code: "F1" },
keyboard: "{Shift>}[F1]",

2
packages/core/package.json
View File

@ -143,7 +143,7 @@
"hpagent": "^1.2.0",
"http-proxy": "^1.18.1",
"immer": "^9.0.19",
"joi": "^17.7.1",
"joi": "^17.9.1",
"js-yaml": "^4.1.0",
"lodash": "^4.17.15",
"marked": "^4.2.12",

14
packages/core/src/common/k8s-api/__tests__/api-manager.test.ts
View File

@ -206,3 +206,17 @@ describe("ApiManager", () => {
});
});
});
describe("ApiManger without storesAndApisCanBeCreated", () => {
let di: DiContainer;
beforeEach(() => {
di = getDiForUnitTesting();
di.override(storesAndApisCanBeCreatedInjectable, () => false);
});
it("should not throw when creating apiManager", () => {
di.inject(apiManagerInjectable);
});
});

4
packages/core/src/common/k8s-api/api-manager/api-manager.ts
View File

@ -25,7 +25,7 @@ export type KubeObjectStoreFrom<Api> = Api extends KubeApi<infer KubeObj, infer
export type FindApiCallback = (api: KubeApi<KubeObject>) => boolean;
interface Dependencies {
export interface ApiManagerDependencies {
readonly apis: IComputedValue<KubeApi[]>;
readonly crdApis: IComputedValue<KubeApi[]>;
readonly stores: IComputedValue<KubeObjectStore[]>;
@ -38,7 +38,7 @@ export class ApiManager {
private readonly defaultCrdStores = observable.map<string, KubeObjectStore>();
private readonly apis = observable.map<string, KubeApi>();
constructor(private readonly dependencies: Dependencies) {
constructor(private readonly dependencies: ApiManagerDependencies) {
// NOTE: this is done to preserve the old behaviour of an API being discoverable using all previous apiBases
autorun(() => {
const apis = iter.chain(this.dependencies.apis.get().values())

29
packages/core/src/common/k8s-api/api-manager/manager.injectable.ts
View File

@ -18,18 +18,23 @@ const apiManagerInjectable = getInjectable({
const computedInjectMany = di.inject(computedInjectManyInjectable);
const storesAndApisCanBeCreated = di.inject(storesAndApisCanBeCreatedInjectionToken);
return new ApiManager({
apis: storesAndApisCanBeCreated
? computedInjectMany(kubeApiInjectionToken)
: computed(() => []),
stores: storesAndApisCanBeCreated
? computedInjectMany(kubeObjectStoreInjectionToken)
: computed(() => []),
crdApis: storesAndApisCanBeCreated
? computedInjectMany(customResourceDefinitionApiInjectionToken)
: computed(() => []),
createCustomResourceStore: di.inject(createCustomResourceStoreInjectable),
});
return new ApiManager((
storesAndApisCanBeCreated
? {
apis: computedInjectMany(kubeApiInjectionToken),
stores: computedInjectMany(kubeObjectStoreInjectionToken),
crdApis: computedInjectMany(customResourceDefinitionApiInjectionToken),
createCustomResourceStore: di.inject(createCustomResourceStoreInjectable),
}
: {
apis: computed(() => []),
stores: computed(() => []),
crdApis: computed(() => []),
createCustomResourceStore: () => {
throw new Error("Tried to create a KubeObjectStore for a CustomResource in a disallowed environment");
},
}
));
},
});

20
packages/core/src/common/k8s-api/kube-api-parse.ts
View File

@ -109,7 +109,25 @@ export function parseKubeApi(path: string): IKubeApiParsed {
};
}
export function createKubeApiURL({ apiPrefix = "/apis", resource, apiVersion, name, namespace }: IKubeApiLinkRef): string {
function isIKubeApiParsed(refOrParsed: IKubeApiLinkRef | IKubeApiParsed): refOrParsed is IKubeApiParsed {
return "apiGroup" in refOrParsed;
}
export function createKubeApiURL(linkRef: IKubeApiLinkRef): string;
export function createKubeApiURL(linkParsed: IKubeApiParsed): string;
export function createKubeApiURL(ref: IKubeApiLinkRef | IKubeApiParsed): string {
if (isIKubeApiParsed(ref)) {
return createKubeApiURL({
apiPrefix: ref.apiPrefix,
resource: ref.resource,
name: ref.name,
namespace: ref.namespace,
apiVersion: `${ref.apiGroup}/${ref.apiVersion}`,
});
}
const { apiPrefix = "/apis", resource, apiVersion, name, namespace } = ref;
const parts = [apiPrefix, apiVersion];
if (namespace) {

2
packages/core/src/common/k8s-api/kube-api.ts
View File

@ -193,7 +193,7 @@ export interface KubeApiWatchOptions<Object extends KubeObject, Data extends Kub
export type KubeApiPatchType = "merge" | "json" | "strategic";
const patchTypeHeaders: Record<KubeApiPatchType, string> = {
export const patchTypeHeaders: Record<KubeApiPatchType, string> = {
"merge": "application/merge-patch+json",
"json": "application/json-patch+json",
"strategic": "application/strategic-merge-patch+json",

42
packages/core/src/common/k8s-api/kube-object.ts
View File

@ -437,6 +437,19 @@ const resourceApplierAnnotationsForFiltering = [
const filterOutResourceApplierAnnotations = (label: string) => !resourceApplierAnnotationsForFiltering.some(key => label.startsWith(key));
export interface RawKubeObject<
Metadata extends KubeObjectMetadata = KubeObjectMetadata,
Status = Record<string, unknown>,
Spec = Record<string, unknown>,
> {
apiVersion: string;
kind: string;
metadata: Metadata;
status?: Status;
spec?: Spec;
managedFields?: any;
}
export class KubeObject<
Metadata extends KubeObjectMetadata<KubeObjectScope> = KubeObjectMetadata<KubeObjectScope>,
Status = unknown,
@ -538,23 +551,6 @@ export class KubeObject<
return Object.entries(labels).map(([name, value]) => `${name}=${value}`);
}
/**
* These must be RFC6902 compliant paths
*/
private static readonly nonEditablePathPrefixes = [
"/metadata/managedFields",
"/status",
];
private static readonly nonEditablePaths = new Set([
"/apiVersion",
"/kind",
"/metadata/name",
"/metadata/selfLink",
"/metadata/resourceVersion",
"/metadata/uid",
...KubeObject.nonEditablePathPrefixes,
]);
constructor(data: KubeJsonApiData<Metadata, Status, Spec>) {
if (typeof data !== "object") {
throw new TypeError(`Cannot create a KubeObject from ${typeof data}`);
@ -684,18 +680,6 @@ export class KubeObject<
* @deprecated use KubeApi.patch instead
*/
async patch(patch: Patch): Promise<KubeJsonApiData | null> {
for (const op of patch) {
if (KubeObject.nonEditablePaths.has(op.path)) {
throw new Error(`Failed to update ${this.kind}: JSON pointer ${op.path} has been modified`);
}
for (const pathPrefix of KubeObject.nonEditablePathPrefixes) {
if (op.path.startsWith(`${pathPrefix}/`)) {
throw new Error(`Failed to update ${this.kind}: Child JSON pointer of ${op.path} has been modified`);
}
}
}
const di = getLegacyGlobalDiForExtensionApi();
const requestKubeObjectPatch = di.inject(requestKubeObjectPatchInjectable);
const result = await requestKubeObjectPatch(this.getName(), this.kind, this.getNs(), patch);

2
packages/core/src/common/protocol-handler/router.ts
View File

@ -209,7 +209,7 @@ export abstract class LensProtocolRouter {
return name;
}
if (!this.dependencies.isExtensionEnabled(extension)) {
if (!extension.isBundled && !this.dependencies.isExtensionEnabled(extension.id)) {
this.dependencies.logger.info(`${LensProtocolRouter.LoggingPrefix}: Extension ${name} matched, but not enabled`);
return name;

29
packages/core/src/common/utils/platform-specific-version.injectable.ts Normal file
View File

@ -0,0 +1,29 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import type { DiContainerForInjection, InjectionToken } from "@ogre-tools/injectable";
import { getInjectable } from "@ogre-tools/injectable";
import platformInjectable from "../vars/platform.injectable";
export interface PlatformSpecific<T> {
instantiate: () => T;
readonly platform: NodeJS.Platform;
}
const platformSpecificVersionInjectable = getInjectable({
id: "platform-specific-version",
instantiate: (di: DiContainerForInjection) => {
const targetPlatform = di.inject(platformInjectable);
return <T>(token: InjectionToken<PlatformSpecific<T>, void>) => (
di.injectMany(token)
.find(impl => impl.platform === targetPlatform)
?.instantiate()
);
},
});
export default platformSpecificVersionInjectable;

4
packages/core/src/extensions/__tests__/extension-loader.test.ts
View File

@ -113,13 +113,13 @@ describe("ExtensionLoader", () => {
});
it("renderer updates extension after ipc broadcast", async () => {
expect(extensionLoader.userExtensions).toEqual(new Map());
expect(extensionLoader.userExtensions.get()).toEqual(new Map());
await extensionLoader.init();
await delay(10);
// Assert the extensions after the extension broadcast event
expect(extensionLoader.userExtensions).toEqual(
expect(extensionLoader.userExtensions.get()).toEqual(
new Map([
["manifest/path", {
absolutePath: "/test/1",

6
packages/core/src/extensions/common-api/app.ts
View File

@ -14,6 +14,7 @@ import { buildVersionInjectionToken } from "../../common/vars/build-semantic-ver
import { asLegacyGlobalForExtensionApi } from "../as-legacy-globals-for-extension-api/as-legacy-global-object-for-extension-api";
import enabledExtensionsInjectable from "../../features/extensions/enabled/common/enabled-extensions.injectable";
import userPreferencesStateInjectable from "../../features/user-preferences/common/state.injectable";
import { lensBuildEnvironmentInjectionToken } from "@k8slens/application";
const userStore = asLegacyGlobalForExtensionApi(userPreferencesStateInjectable);
const enabledExtensions = asLegacyGlobalForExtensionApi(enabledExtensionsInjectable);
@ -53,6 +54,11 @@ export const App = {
return di.inject(isLinuxInjectable);
},
get lensBuildEnvironment() {
const di = getLegacyGlobalDiForExtensionApi();
return di.inject(lensBuildEnvironmentInjectionToken);
},
/**
* @deprecated This value is now `""` and is left here for backwards compatibility.
*/

48
packages/core/src/extensions/extension-discovery/extension-discovery.ts
View File

@ -10,14 +10,14 @@ import { broadcastMessage, ipcMainHandle, ipcRendererOn } from "../../common/ipc
import { toJS } from "../../common/utils";
import { isErrnoException } from "@k8slens/utilities";
import type { ExtensionLoader } from "../extension-loader";
import type { InstalledExtension, LensExtensionId, LensExtensionManifest } from "@k8slens/legacy-extensions";
import type { InstalledExtension, LensExtensionId, LensExtensionManifest, ExternalInstalledExtension } from "@k8slens/legacy-extensions";
import type { ExtensionInstallationStateStore } from "../extension-installation-state-store/extension-installation-state-store";
import { extensionDiscoveryStateChannel } from "../../common/ipc/extension-handling";
import { requestInitialExtensionDiscovery } from "../../renderer/ipc";
import type { ReadJson } from "../../common/fs/read-json-file.injectable";
import type { Logger } from "../../common/logger";
import type { PathExists } from "../../common/fs/path-exists.injectable";
import type { Watch } from "../../common/fs/watch/watch.injectable";
import type { Watch, Watcher } from "../../common/fs/watch/watch.injectable";
import type { Stats } from "fs";
import type { LStat } from "../../common/fs/lstat.injectable";
import type { ReadDirectory } from "../../common/fs/read-directory.injectable";
@ -73,10 +73,6 @@ interface ExtensionDiscoveryChannelMessage {
*/
const isDirectoryLike = (lstat: Stats) => lstat.isDirectory() || lstat.isSymbolicLink();
interface LoadFromFolderOptions {
isBundled?: boolean;
}
interface ExtensionDiscoveryEvents {
add: (ext: InstalledExtension) => void;
remove: (extId: LensExtensionId) => void;
@ -153,6 +149,8 @@ export class ExtensionDiscovery {
});
}
private _watch: Watcher<false>|undefined;
/**
* Watches for added/removed local extensions.
* Dependencies are installed automatically after an extension folder is copied.
@ -163,7 +161,7 @@ export class ExtensionDiscovery {
// Wait until .load() has been called and has been resolved
await this.whenLoaded;
this.dependencies.watch(this.localFolderPath, {
this._watch = this.dependencies.watch(this.localFolderPath, {
// For adding and removing symlinks to work, the depth has to be 1.
depth: 1,
ignoreInitial: true,
@ -183,6 +181,12 @@ export class ExtensionDiscovery {
.on("unlink", this.handleWatchUnlinkEvent);
}
async stopWatchingExtensions() {
this.dependencies.logger.info(`${logModule} stopping the watch for extensions`);
await this._watch?.close();
}
handleWatchFileAdd = async (manifestPath: string): Promise<void> => {
// e.g. "foo/package.json"
const relativePath = this.dependencies.getRelativePath(this.localFolderPath, manifestPath);
@ -271,7 +275,7 @@ export class ExtensionDiscovery {
* @param extensionId The ID of the extension to uninstall.
*/
async uninstallExtension(extensionId: LensExtensionId): Promise<void> {
const extension = this.extensions.get(extensionId) ?? this.dependencies.extensionLoader.getExtension(extensionId);
const extension = this.extensions.get(extensionId) ?? this.dependencies.extensionLoader.getExtensionById(extensionId);
if (!extension) {
return void this.dependencies.logger.warn(`${logModule} could not uninstall extension, not found`, { id: extensionId });
@ -330,24 +334,26 @@ export class ExtensionDiscovery {
* Returns InstalledExtension from path to package.json file.
* Also updates this.packagesJson.
*/
protected async getByManifest(manifestPath: string, { isBundled = false } = {}): Promise<InstalledExtension | null> {
protected async loadExtensionFromFolder(folderPath: string): Promise<ExternalInstalledExtension | null> {
const manifestPath = this.dependencies.joinPaths(folderPath, manifestFilename);
try {
const manifest = await this.dependencies.readJsonFile(manifestPath) as unknown as LensExtensionManifest;
const id = isBundled ? manifestPath : this.getInstalledManifestPath(manifest.name);
const isEnabled = this.dependencies.isExtensionEnabled({ id, isBundled });
const id = this.getInstalledManifestPath(manifest.name);
const isEnabled = this.dependencies.isExtensionEnabled(id);
const extensionDir = this.dependencies.getDirnameOfPath(manifestPath);
const npmPackage = this.dependencies.joinPaths(extensionDir, `${manifest.name}-${manifest.version}.tgz`);
const absolutePath = this.dependencies.isProduction && await this.dependencies.pathExists(npmPackage)
? npmPackage
: extensionDir;
const isCompatible = isBundled || this.dependencies.isCompatibleExtension(manifest);
const isCompatible = this.dependencies.isCompatibleExtension(manifest);
return {
id,
absolutePath,
manifestPath: id,
manifest,
isBundled,
isBundled: false,
isEnabled,
isCompatible,
};
@ -363,14 +369,14 @@ export class ExtensionDiscovery {
}
}
async ensureExtensions(): Promise<Map<LensExtensionId, InstalledExtension>> {
async ensureExtensions(): Promise<Map<LensExtensionId, ExternalInstalledExtension>> {
const userExtensions = await this.loadFromFolder(this.localFolderPath);
return this.extensions = new Map(userExtensions.map(extension => [extension.id, extension]));
}
async loadFromFolder(folderPath: string): Promise<InstalledExtension[]> {
const extensions: InstalledExtension[] = [];
async loadFromFolder(folderPath: string): Promise<ExternalInstalledExtension[]> {
const extensions: ExternalInstalledExtension[] = [];
const paths = await this.dependencies.readDirectory(folderPath);
for (const fileName of paths) {
@ -403,16 +409,6 @@ export class ExtensionDiscovery {
return extensions;
}
/**
* Loads extension from absolute path, updates this.packagesJson to include it and returns the extension.
* @param folderPath Folder path to extension
*/
async loadExtensionFromFolder(folderPath: string, { isBundled = false }: LoadFromFolderOptions = {}): Promise<InstalledExtension | null> {
const manifestPath = this.dependencies.joinPaths(folderPath, manifestFilename);
return this.getByManifest(manifestPath, { isBundled });
}
toJSON(): ExtensionDiscoveryChannelMessage {
return toJS({
isLoaded: this.isLoaded,

23
packages/core/src/extensions/extension-discovery/stop-watching-extensions-on-quit.injectable.ts Normal file
View File

@ -0,0 +1,23 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import { beforeQuitOfBackEndInjectionToken } from "../../main/start-main-application/runnable-tokens/phases";
import extensionDiscoveryInjectable from "./extension-discovery.injectable";
const stopWatchingExtensionsOnQuitInjectable = getInjectable({
id: "stop-watching-extensions-on-quit",
instantiate: (di) => ({
run: async () => {
const extensionDiscovery = di.inject(extensionDiscoveryInjectable);
await extensionDiscovery.stopWatchingExtensions();
},
}),
injectionToken: beforeQuitOfBackEndInjectionToken,
});
export default stopWatchingExtensionsOnQuitInjectable;

7
packages/core/src/extensions/extension-loader/create-extension-instance.token.ts
View File

@ -3,11 +3,14 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import type { LensExtensionConstructor, InstalledExtension } from "@k8slens/legacy-extensions";
import type { LensExtensionConstructor, BundledInstalledExtension, ExternalInstalledExtension, BundledLensExtensionConstructor } from "@k8slens/legacy-extensions";
import { getInjectionToken } from "@ogre-tools/injectable";
import type { LensExtension } from "../lens-extension";
export type CreateExtensionInstance = (ExtensionClass: LensExtensionConstructor, extension: InstalledExtension) => LensExtension;
export interface CreateExtensionInstance {
(ExtensionClass: LensExtensionConstructor, extension: ExternalInstalledExtension): LensExtension;
(ExtensionClass: BundledLensExtensionConstructor, extension: BundledInstalledExtension): LensExtension;
}
export const createExtensionInstanceInjectionToken = getInjectionToken<CreateExtensionInstance>({
id: "create-extension-instance-token",

109
packages/core/src/extensions/extension-loader/extension-loader.ts
View File

@ -6,9 +6,10 @@
import { ipcMain, ipcRenderer } from "electron";
import { isEqual } from "lodash";
import type { ObservableMap } from "mobx";
import { action, computed, makeObservable, toJS, observable, observe, reaction, when } from "mobx";
import { runInAction, action, computed, toJS, observable, reaction, when } from "mobx";
import { broadcastMessage, ipcMainOn, ipcRendererOn, ipcMainHandle } from "../../common/ipc";
import { isDefined } from "@k8slens/utilities";
import { isDefined, iter } from "@k8slens/utilities";
import type { ExternalInstalledExtension, InstalledExtension, LensExtensionConstructor, LensExtensionId, BundledExtension } from "@k8slens/legacy-extensions";
import type { LensExtension } from "../lens-extension";
import { extensionLoaderFromMainChannel, extensionLoaderFromRendererChannel } from "../../common/ipc/extension-handling";
import { requestExtensionLoaderInitialState } from "../../renderer/ipc";
@ -19,7 +20,6 @@ import type { Extension } from "./extension/extension.injectable";
import type { Logger } from "../../common/logger";
import type { JoinPaths } from "../../common/path/join-paths.injectable";
import type { GetDirnameOfPath } from "../../common/path/get-dirname.injectable";
import type { LensExtensionId, BundledExtension, InstalledExtension, LensExtensionConstructor } from "@k8slens/legacy-extensions";
import type { UpdateExtensionsState } from "../../features/extensions/enabled/common/update-state.injectable";
const logModule = "[EXTENSIONS-LOADER]";
@ -60,51 +60,21 @@ export class ExtensionLoader {
*/
protected readonly nonInstancesByName = observable.set<string>();
/**
* This is updated by the `observe` in the constructor. DO NOT write directly to it
*/
protected readonly instancesByName = observable.map<string, LensExtension>();
protected readonly instancesByName = computed(() => new Map((
iter.chain(this.dependencies.extensionInstances.entries())
.map(([, instance]) => [instance.name, instance])
)));
private readonly onRemoveExtensionId = new EventEmitter<[string]>();
@observable isLoaded = false;
readonly isLoaded = observable.box(false);
get whenLoaded() {
return when(() => this.isLoaded);
}
constructor(protected readonly dependencies: Dependencies) {}
constructor(protected readonly dependencies: Dependencies) {
makeObservable(this);
observe(this.dependencies.extensionInstances, change => {
switch (change.type) {
case "add":
if (this.instancesByName.has(change.newValue.name)) {
throw new TypeError("Extension names must be unique");
}
this.instancesByName.set(change.newValue.name, change.newValue);
break;
case "delete":
this.instancesByName.delete(change.oldValue.name);
break;
case "update":
throw new Error("Extension instances shouldn't be updated");
}
});
}
@computed get userExtensions(): Map<LensExtensionId, InstalledExtension> {
const extensions = this.toJSON();
extensions.forEach((ext, extId) => {
if (ext.isBundled) {
extensions.delete(extId);
}
});
return extensions;
}
readonly userExtensions = computed(() => new Map((
this.extensions.toJSON()
.filter(([, extension]) => !extension.isBundled)
)));
/**
* Get the extension instance by its manifest name
@ -120,19 +90,18 @@ export class ExtensionLoader {
return null;
}
return this.instancesByName.get(name);
return this.instancesByName.get().get(name);
}
// Transform userExtensions to a state object for storing into ExtensionsStore
@computed get storeState() {
return Array.from(this.userExtensions)
.map(([extId, extension]) => [extId, {
enabled: extension.isEnabled,
name: extension.manifest.name,
}] as const);
}
readonly storeState = computed(() => Array.from(
this.userExtensions.get(),
([extId, extension]) => [extId, {
enabled: extension.isEnabled,
name: extension.manifest.name,
}] as const,
));
@action
async init() {
if (ipcMain) {
await this.initMain();
@ -140,7 +109,7 @@ export class ExtensionLoader {
await this.initRenderer();
}
await Promise.all([this.whenLoaded]);
await when(() => this.isLoaded.get());
// broadcasting extensions between main/renderer processes
reaction(() => this.toJSON(), () => this.broadcastExtensions(), {
@ -148,8 +117,7 @@ export class ExtensionLoader {
});
reaction(
() => this.storeState,
() => this.storeState.get(),
(state) => {
this.dependencies.updateExtensionsState(state);
},
@ -199,18 +167,20 @@ export class ExtensionLoader {
setIsEnabled(lensExtensionId: LensExtensionId, isEnabled: boolean) {
const extension = this.extensions.get(lensExtensionId);
assert(extension, `Must register extension ${lensExtensionId} with before enabling it`);
assert(extension, `Extension "${lensExtensionId}" must be registered before it can be enabled.`);
assert(!extension.isBundled, `Cannot change the enabled state of a bundled extension`);
extension.isEnabled = isEnabled;
}
protected async initMain() {
this.isLoaded = true;
runInAction(() => {
this.isLoaded.set(true);
});
await this.autoInitExtensions();
ipcMainHandle(extensionLoaderFromMainChannel, () => {
return Array.from(this.toJSON());
});
ipcMainHandle(extensionLoaderFromMainChannel, () => [...this.toJSON()]);
ipcMainOn(extensionLoaderFromRendererChannel, (event, extensions: [LensExtensionId, InstalledExtension][]) => {
this.syncExtensions(extensions);
@ -219,7 +189,9 @@ export class ExtensionLoader {
protected async initRenderer() {
const extensionListHandler = (extensions: [LensExtensionId, InstalledExtension][]) => {
this.isLoaded = true;
runInAction(() => {
this.isLoaded.set(true);
});
this.syncExtensions(extensions);
const receivedExtensionIds = extensions.map(([lensExtensionId]) => lensExtensionId);
@ -255,10 +227,10 @@ export class ExtensionLoader {
}
protected async loadBundledExtensions() {
return this.dependencies.bundledExtensions
.map(extension => {
const bundledExtensions = await Promise.all((this.dependencies.bundledExtensions
.map(async extension => {
try {
const LensExtensionClass = extension[this.dependencies.extensionEntryPointName]();
const LensExtensionClass = await extension[this.dependencies.extensionEntryPointName]();
if (!LensExtensionClass) {
return null;
@ -291,7 +263,9 @@ export class ExtensionLoader {
return null;
}
})
.filter(isDefined);
));
return bundledExtensions.filter(isDefined);
}
protected async loadExtensions(extensions: ExtensionBeingActivated[]): Promise<ExtensionLoading[]> {
@ -332,6 +306,7 @@ export class ExtensionLoader {
// 4. Return ExtensionLoading[]
return [...installedExtensions.entries()]
.filter((entry): entry is [string, ExternalInstalledExtension] => !entry[1].isBundled)
.map(([extId, extension]) => {
const alreadyInit = this.dependencies.extensionInstances.has(extId) || this.nonInstancesByName.has(extension.manifest.name);
@ -391,7 +366,7 @@ export class ExtensionLoader {
return loadedExtensions;
}
protected requireExtension(extension: InstalledExtension): LensExtensionConstructor | null {
protected requireExtension(extension: ExternalInstalledExtension): LensExtensionConstructor | null {
const extRelativePath = extension.manifest[this.dependencies.extensionEntryPointName];
if (!extRelativePath) {
@ -411,7 +386,7 @@ export class ExtensionLoader {
return null;
}
getExtension(extId: LensExtensionId) {
getExtensionById(extId: LensExtensionId) {
return this.extensions.get(extId);
}

7
packages/core/src/extensions/lens-extension.ts
View File

@ -9,7 +9,6 @@ import type { LensExtensionDependencies } from "./lens-extension-set-dependencie
import type { ProtocolHandlerRegistration } from "../common/protocol-handler/registration";
import type { InstalledExtension, LegacyLensExtension, LensExtensionId, LensExtensionManifest } from "@k8slens/legacy-extensions";
export const lensExtensionDependencies = Symbol("lens-extension-dependencies");
export const Disposers = Symbol("disposers");
@ -42,14 +41,12 @@ export class LensExtension<
[Disposers] = disposer();
constructor({ id, manifest, manifestPath, isBundled }: InstalledExtension) {
makeObservable(this);
// id is the name of the manifest
this.id = id;
this.manifest = manifest;
this.manifest = manifest as LensExtensionManifest;
this.manifestPath = manifestPath;
this.isBundled = !!isBundled;
makeObservable(this);
}
get name() {

9
packages/core/src/features/certificate-authorities/common/request-system-cas-token.ts
View File

@ -4,7 +4,14 @@
*/
import { getInjectionToken } from "@ogre-tools/injectable";
import type { PlatformSpecific } from "../../../common/utils/platform-specific-version.injectable";
export const requestSystemCAsInjectionToken = getInjectionToken<() => Promise<string[]>>({
export type RequestSystemCAs = () => Promise<string[]>;
export const platformSpecificRequestSystemCAsInjectionToken = getInjectionToken<PlatformSpecific<RequestSystemCAs>>({
id: "platform-specific-request-system-cas-token",
});
export const requestSystemCAsInjectionToken = getInjectionToken<RequestSystemCAs>({
id: "request-system-cas-token",
});

60
packages/core/src/features/certificate-authorities/main/darwin-request-system-cas.injectable.ts Normal file
View File

@ -0,0 +1,60 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import execFileInjectable from "../../../common/fs/exec-file.injectable";
import loggerInjectable from "../../../common/logger.injectable";
import type { AsyncResult } from "@k8slens/utilities";
import { platformSpecificRequestSystemCAsInjectionToken } from "../common/request-system-cas-token";
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Cheatsheet#other_assertions
const certSplitPattern = /(?=-----BEGIN\sCERTIFICATE-----)/g;
const darwinRequestSystemCAsInjectable = getInjectable({
id: "darwin-request-system-cas",
instantiate: (di) => ({
platform: "darwin" as const,
instantiate: () => {
const execFile = di.inject(execFileInjectable);
const logger = di.inject(loggerInjectable);
const execSecurity = async (...args: string[]): AsyncResult<string[]> => {
const result = await execFile("/usr/bin/security", args);
if (!result.callWasSuccessful) {
return {
callWasSuccessful: false,
error: result.error.stderr || result.error.message,
};
}
return {
callWasSuccessful: true,
response: result.response.split(certSplitPattern),
};
};
return async () => {
const [trustedResult, rootCAResult] = await Promise.all([
execSecurity("find-certificate", "-a", "-p"),
execSecurity("find-certificate", "-a", "-p", "/System/Library/Keychains/SystemRootCertificates.keychain"),
]);
if (!trustedResult.callWasSuccessful) {
logger.warn(`[INJECT-CAS]: Error retrieving trusted CAs: ${trustedResult.error}`);
} else if (!rootCAResult.callWasSuccessful) {
logger.warn(`[INJECT-CAS]: Error retrieving root CAs: ${rootCAResult.error}`);
} else {
return [...new Set([...trustedResult.response, ...rootCAResult.response])];
}
return [];
};
},
}),
causesSideEffects: true,
injectionToken: platformSpecificRequestSystemCAsInjectionToken,
});
export default darwinRequestSystemCAsInjectable;

17
packages/core/src/features/certificate-authorities/main/linux-request-system-cas.injectable.ts Normal file
View File

@ -0,0 +1,17 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import { platformSpecificRequestSystemCAsInjectionToken } from "../common/request-system-cas-token";
const linuxRequestSystemCAsInjectable = getInjectable({
id: "linux-request-system-cas",
instantiate: () => ({
platform: "linux" as const,
instantiate: () => async () => [],
}),
injectionToken: platformSpecificRequestSystemCAsInjectionToken,
});
export default linuxRequestSystemCAsInjectable;

9
packages/core/src/features/certificate-authorities/main/request-system-cas.global-override-for-injectable.ts Normal file
View File

@ -0,0 +1,9 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getGlobalOverride } from "@k8slens/test-utils";
import requestSystemCAsInjectable from "./request-system-cas.injectable";
export default getGlobalOverride(requestSystemCAsInjectable, () => async () => []);

57
packages/core/src/features/certificate-authorities/main/request-system-cas.injectable.darwin.ts
View File

@ -1,57 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import execFileInjectable from "../../../common/fs/exec-file.injectable";
import loggerInjectable from "../../../common/logger.injectable";
import type { AsyncResult } from "@k8slens/utilities";
import { requestSystemCAsInjectionToken } from "../common/request-system-cas-token";
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Cheatsheet#other_assertions
const certSplitPattern = /(?=-----BEGIN\sCERTIFICATE-----)/g;
const requestSystemCAsInjectable = getInjectable({
id: "request-system-cas",
instantiate: (di) => {
const execFile = di.inject(execFileInjectable);
const logger = di.inject(loggerInjectable);
const execSecurity = async (...args: string[]): AsyncResult<string[]> => {
const result = await execFile("/usr/bin/security", args);
if (!result.callWasSuccessful) {
return {
callWasSuccessful: false,
error: result.error.stderr || result.error.message,
};
}
return {
callWasSuccessful: true,
response: result.response.split(certSplitPattern),
};
};
return async () => {
const [trustedResult, rootCAResult] = await Promise.all([
execSecurity("find-certificate", "-a", "-p"),
execSecurity("find-certificate", "-a", "-p", "/System/Library/Keychains/SystemRootCertificates.keychain"),
]);
if (!trustedResult.callWasSuccessful) {
logger.warn(`[INJECT-CAS]: Error retreiving trusted CAs: ${trustedResult.error}`);
} else if (!rootCAResult.callWasSuccessful) {
logger.warn(`[INJECT-CAS]: Error retreiving root CAs: ${rootCAResult.error}`);
} else {
return [...new Set([...trustedResult.response, ...rootCAResult.response])];
}
return [];
};
},
causesSideEffects: true,
injectionToken: requestSystemCAsInjectionToken,
});
export default requestSystemCAsInjectable;

14
packages/core/src/features/certificate-authorities/main/request-system-cas.injectable.linux.ts
View File

@ -1,14 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import { requestSystemCAsInjectionToken } from "../common/request-system-cas-token";
const requestSystemCAsInjectable = getInjectable({
id: "request-system-cas",
instantiate: () => async () => [],
injectionToken: requestSystemCAsInjectionToken,
});
export default requestSystemCAsInjectable;

14
packages/core/src/features/certificate-authorities/main/request-system-cas.injectable.testing-env.ts
View File

@ -1,14 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import { requestSystemCAsInjectionToken } from "../common/request-system-cas-token";
const requestSystemCAsInjectable = getInjectable({
id: "request-system-cas",
instantiate: () => async () => [],
injectionToken: requestSystemCAsInjectionToken,
});
export default requestSystemCAsInjectable;

20
packages/core/src/features/certificate-authorities/main/request-system-cas.injectable.ts Normal file
View File

@ -0,0 +1,20 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import platformSpecificVersionInjectable from "../../../common/utils/platform-specific-version.injectable";
import { platformSpecificRequestSystemCAsInjectionToken, requestSystemCAsInjectionToken } from "../common/request-system-cas-token";
const requestSystemCAsInjectable = getInjectable({
id: "request-system-cas",
instantiate: (di) => {
const platformSpecificVersion = di.inject(platformSpecificVersionInjectable);
const platformSpecificRequestSystemCAs = platformSpecificVersion(platformSpecificRequestSystemCAsInjectionToken);
return platformSpecificRequestSystemCAs ?? (async () => []);
},
injectionToken: requestSystemCAsInjectionToken,
});
export default requestSystemCAsInjectable;

56
packages/core/src/features/certificate-authorities/main/request-system-cas.injectable.win32.ts
View File

@ -1,56 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import execFileInjectable from "../../../common/fs/exec-file.injectable";
import loggerInjectable from "../../../common/logger.injectable";
import { requestSystemCAsInjectionToken } from "../common/request-system-cas-token";
const pemEncoding = (hexEncodedCert: String) => {
const certData = Buffer.from(hexEncodedCert, "hex").toString("base64");
const lines = ["-----BEGIN CERTIFICATE-----"];
for (let i = 0; i < certData.length; i += 64) {
lines.push(certData.substring(i, i + 64));
}
lines.push("-----END CERTIFICATE-----", "");
return lines.join("\r\n");
};
const requestSystemCAsInjectable = getInjectable({
id: "request-system-cas",
instantiate: (di) => {
const wincaRootsExePath: string = __non_webpack_require__.resolve("win-ca/lib/roots.exe");
const execFile = di.inject(execFileInjectable);
const logger = di.inject(loggerInjectable);
return async () => {
/**
* This needs to be done manually because for some reason calling the api from "win-ca"
* directly fails to load "child_process" correctly on renderer
*/
const result = await execFile(wincaRootsExePath, {
maxBuffer: 128 * 1024 * 1024, // 128 MiB
});
if (!result.callWasSuccessful) {
logger.warn(`[INJECT-CAS]: Error retreiving CAs`, result.error);
return [];
}
return result
.response
.split("\r\n")
.filter(Boolean)
.map(pemEncoding);
};
},
causesSideEffects: true,
injectionToken: requestSystemCAsInjectionToken,
});
export default requestSystemCAsInjectable;

59
packages/core/src/features/certificate-authorities/main/win32-request-system-cas.injectable.ts Normal file
View File

@ -0,0 +1,59 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import execFileInjectable from "../../../common/fs/exec-file.injectable";
import loggerInjectable from "../../../common/logger.injectable";
import { platformSpecificRequestSystemCAsInjectionToken } from "../common/request-system-cas-token";
const pemEncoding = (hexEncodedCert: String) => {
const certData = Buffer.from(hexEncodedCert, "hex").toString("base64");
const lines = ["-----BEGIN CERTIFICATE-----"];
for (let i = 0; i < certData.length; i += 64) {
lines.push(certData.substring(i, i + 64));
}
lines.push("-----END CERTIFICATE-----", "");
return lines.join("\r\n");
};
const win32RequestSystemCAsInjectable = getInjectable({
id: "win32-request-system-cas",
instantiate: (di) => ({
platform: "win32" as const,
instantiate: () => {
const winCARootsExePath: string = __non_webpack_require__.resolve("win-ca/lib/roots.exe");
const execFile = di.inject(execFileInjectable);
const logger = di.inject(loggerInjectable);
return async () => {
/**
* This needs to be done manually because for some reason calling the api from "win-ca"
* directly fails to load "child_process" correctly on renderer
*/
const result = await execFile(winCARootsExePath, {
maxBuffer: 128 * 1024 * 1024, // 128 MiB
});
if (!result.callWasSuccessful) {
logger.warn(`[INJECT-CAS]: Error retrieving CAs`, result.error);
return [];
}
return result
.response
.split("\r\n")
.filter(Boolean)
.map(pemEncoding);
};
},
}),
causesSideEffects: true,
injectionToken: platformSpecificRequestSystemCAsInjectionToken,
});
export default win32RequestSystemCAsInjectable;

2
packages/core/src/features/cluster/namespaces/__snapshots__/edit-namespace-from-new-tab.test.tsx.snap
View File

@ -7469,6 +7469,8 @@ metadata:
selfLink: /apis/some-api-version/namespaces/some-uid
somePropertyToBeRemoved: some-value
somePropertyToBeChanged: some-old-value
labels:
k8slens-edit-resource-version: some-api-version
</textarea>
</div>

41
packages/core/src/features/cluster/namespaces/edit-namespace-from-new-tab.test.tsx
View File

@ -12,8 +12,6 @@ import createEditResourceTabInjectable from "../../../renderer/components/dock/e
import getRandomIdForEditResourceTabInjectable from "../../../renderer/components/dock/edit-resource/get-random-id-for-edit-resource-tab.injectable";
import type { AsyncFnMock } from "@async-fn/jest";
import asyncFn from "@async-fn/jest";
import type { CallForResource } from "../../../renderer/components/dock/edit-resource/edit-resource-model/call-for-resource/call-for-resource.injectable";
import callForResourceInjectable from "../../../renderer/components/dock/edit-resource/edit-resource-model/call-for-resource/call-for-resource.injectable";
import type { CallForPatchResource } from "../../../renderer/components/dock/edit-resource/edit-resource-model/call-for-patch-resource/call-for-patch-resource.injectable";
import callForPatchResourceInjectable from "../../../renderer/components/dock/edit-resource/edit-resource-model/call-for-patch-resource/call-for-patch-resource.injectable";
import dockStoreInjectable from "../../../renderer/components/dock/dock/store.injectable";
@ -23,6 +21,8 @@ import showErrorNotificationInjectable from "../../../renderer/components/notifi
import readJsonFileInjectable from "../../../common/fs/read-json-file.injectable";
import directoryForLensLocalStorageInjectable from "../../../common/directory-for-lens-local-storage/directory-for-lens-local-storage.injectable";
import hostedClusterIdInjectable from "../../../renderer/cluster-frame-context/hosted-cluster-id.injectable";
import type { CallForResource } from "../../../renderer/components/dock/edit-resource/edit-resource-model/call-for-resource/call-for-resource.injectable";
import callForResourceInjectable from "../../../renderer/components/dock/edit-resource/edit-resource-model/call-for-resource/call-for-resource.injectable";
describe("cluster/namespaces - edit namespace from new tab", () => {
let builder: ApplicationBuilder;
@ -225,10 +225,16 @@ metadata:
expect(rendered.baseElement).toMatchSnapshot();
});
it("calls for save with empty values", () => {
it("calls for save with just the adding version label", () => {
expect(callForPatchResourceMock).toHaveBeenCalledWith(
someNamespace,
[],
[{
op: "add",
path: "/metadata/labels",
value: {
"k8slens-edit-resource-version": "some-api-version",
},
}],
);
});
@ -532,6 +538,13 @@ metadata:
path: "/metadata/someAddedProperty",
value: "some-new-value",
},
{
op: "add",
path: "/metadata/labels",
value: {
"k8slens-edit-resource-version": "some-api-version",
},
},
{
op: "replace",
path: "/metadata/somePropertyToBeChanged",
@ -759,7 +772,7 @@ metadata:
`);
});
it("when selecting to save, calls for save of second namespace", () => {
it("when selecting to save, calls for save of second namespace with just the add edit version label", () => {
callForPatchResourceMock.mockClear();
const saveButton = rendered.getByTestId(
@ -770,7 +783,13 @@ metadata:
expect(callForPatchResourceMock).toHaveBeenCalledWith(
someOtherNamespace,
[],
[{
op: "add",
path: "/metadata/labels",
value: {
"k8slens-edit-resource-version": "some-api-version",
},
}],
);
});
@ -826,7 +845,7 @@ metadata:
`);
});
it("when selecting to save, calls for save of first namespace", () => {
it("when selecting to save, calls for save of first namespace with just the new edit version label", () => {
callForPatchResourceMock.mockClear();
const saveButton = rendered.getByTestId(
@ -837,7 +856,13 @@ metadata:
expect(callForPatchResourceMock).toHaveBeenCalledWith(
someNamespace,
[],
[ {
op: "add",
path: "/metadata/labels",
value: {
"k8slens-edit-resource-version": "some-api-version",
},
}],
);
});
});

2
packages/core/src/features/extensions/__snapshots__/navigation-using-application-menu.test.ts.snap
View File

@ -376,7 +376,7 @@ exports[`extensions - navigation using application menu when navigating to exten
<p>
Add new features via Lens Extensions. Check out the
<a
href="https://docs.k8slens.dev/extensions/"
href="https://docs.k8slens.dev/extensions/lens-extensions"
rel="noreferrer"
target="_blank"
>

9
packages/core/src/features/extensions/enabled/common/is-enabled.injectable.ts
View File

@ -5,19 +5,14 @@
import { getInjectable } from "@ogre-tools/injectable";
import enabledExtensionsStateInjectable from "./state.injectable";
export interface IsEnabledExtensionDescriptor {
readonly id: string;
readonly isBundled: boolean;
}
export type IsExtensionEnabled = (desc: IsEnabledExtensionDescriptor) => boolean;
export type IsExtensionEnabled = (id: string) => boolean;
const isExtensionEnabledInjectable = getInjectable({
id: "is-extension-enabled",
instantiate: (di): IsExtensionEnabled => {
const state = di.inject(enabledExtensionsStateInjectable);
return ({ id, isBundled }) => isBundled || (state.get(id)?.enabled ?? false);
return (id) => (state.get(id)?.enabled ?? false);
},
});

6
packages/core/src/jest.setup.ts
View File

@ -58,7 +58,7 @@ jest.mock("./renderer/components/tooltip/withTooltip");
jest.mock("monaco-editor");
const getInjectables = (environment: "renderer" | "main", filePathGlob: string) => [
...glob.sync(`./{common,extensions,${environment}}/**/${filePathGlob}`, {
...glob.sync(`./{common,extensions,${environment},test-env}/**/${filePathGlob}`, {
cwd: __dirname,
}),
@ -70,10 +70,10 @@ const getInjectables = (environment: "renderer" | "main", filePathGlob: string)
global.injectablePaths = {
renderer: {
globalOverridePaths: getInjectables("renderer", "*.global-override-for-injectable.{ts,tsx}"),
paths: getInjectables("renderer", "*.{injectable,injectable.testing-env}.{ts,tsx}"),
paths: getInjectables("renderer", "*.injectable.{ts,tsx}"),
},
main: {
globalOverridePaths: getInjectables("main", "*.global-override-for-injectable.{ts,tsx}"),
paths: getInjectables("main", "*.{injectable,injectable.testing-env}.{ts,tsx}"),
paths: getInjectables("main", "*.injectable.{ts,tsx}"),
},
};

12
packages/core/src/main/catalog-sources/kubeconfig-sync/manager.ts
View File

@ -98,11 +98,19 @@ export class KubeconfigSyncManager {
@action
protected stopOldSync(filePath: string): void {
if (!this.sources.delete(filePath)) {
// already stopped
const source = this.sources.get(filePath);
// already stopped
if (!source) {
return this.dependencies.logger.debug(`no syncing file/folder to stop`, { filePath });
}
const [, disposer] = source;
disposer();
this.sources.delete(filePath);
this.dependencies.logger.info(`stopping sync of file/folder`, { filePath });
this.dependencies.logger.debug(`${this.sources.size} files/folders watched`, { files: Array.from(this.sources.keys()) });
}

2
packages/core/src/main/extension-loader/create-extension-instance.injectable.ts
View File

@ -24,7 +24,7 @@ const createExtensionInstanceInjectable = getInjectable({
};
return (ExtensionClass, extension) => {
const instance = new ExtensionClass(extension) as LensMainExtension;
const instance = new ExtensionClass(extension as any) as LensMainExtension;
(instance as Writable<LensMainExtension>)[lensExtensionDependencies] = deps;

34
packages/core/src/main/protocol-handler/__test__/router.test.ts
View File

@ -10,16 +10,12 @@ import { noop } from "@k8slens/utilities";
import type { LensProtocolRouterMain } from "../lens-protocol-router-main/lens-protocol-router-main";
import { getDiForUnitTesting } from "../../getDiForUnitTesting";
import lensProtocolRouterMainInjectable from "../lens-protocol-router-main/lens-protocol-router-main.injectable";
import getConfigurationFileModelInjectable from "../../../common/get-configuration-file-model/get-configuration-file-model.injectable";
import { LensExtension } from "../../../extensions/lens-extension";
import type { ObservableMap } from "mobx";
import { runInAction } from "mobx";
import extensionInstancesInjectable from "../../../extensions/extension-loader/extension-instances.injectable";
import directoryForUserDataInjectable from "../../../common/app-paths/directory-for-user-data/directory-for-user-data.injectable";
import broadcastMessageInjectable from "../../../common/ipc/broadcast-message.injectable";
import pathExistsSyncInjectable from "../../../common/fs/path-exists-sync.injectable";
import pathExistsInjectable from "../../../common/fs/path-exists.injectable";
import readJsonSyncInjectable from "../../../common/fs/read-json-sync.injectable";
import writeJsonSyncInjectable from "../../../common/fs/write-json-sync.injectable";
import type { LensExtensionId } from "@k8slens/legacy-extensions";
import type { LensExtensionState } from "../../../features/extensions/enabled/common/state.injectable";
import enabledExtensionsStateInjectable from "../../../features/extensions/enabled/common/state.injectable";
@ -39,16 +35,8 @@ describe("protocol router tests", () => {
beforeEach(async () => {
const di = getDiForUnitTesting();
di.override(pathExistsInjectable, () => () => { throw new Error("tried call pathExists without override"); });
di.override(pathExistsSyncInjectable, () => () => { throw new Error("tried call pathExistsSync without override"); });
di.override(readJsonSyncInjectable, () => () => { throw new Error("tried call readJsonSync without override"); });
di.override(writeJsonSyncInjectable, () => () => { throw new Error("tried call writeJsonSync without override"); });
enabledExtensions = di.inject(enabledExtensionsStateInjectable);
di.permitSideEffects(getConfigurationFileModelInjectable);
di.override(directoryForUserDataInjectable, () => "some-directory-for-user-data");
di.override(directoryForUserDataInjectable, () => "/some-directory-for-user-data");
broadcastMessageMock = jest.fn();
di.override(broadcastMessageInjectable, () => broadcastMessageMock);
@ -56,7 +44,9 @@ describe("protocol router tests", () => {
extensionInstances = di.inject(extensionInstancesInjectable);
lpr = di.inject(lensProtocolRouterMainInjectable);
lpr.rendererLoaded = true;
runInAction(() => {
lpr.rendererLoaded.set(true);
});
});
it("should broadcast invalid protocol on non-lens URLs", async () => {
@ -69,7 +59,19 @@ describe("protocol router tests", () => {
expect(broadcastMessageMock).toBeCalledWith(ProtocolHandlerInvalid, "invalid host", "lens://foobar");
});
it("should not throw when has valid host", async () => {
it("should broadcast internal route when called with valid host", async () => {
lpr.addInternalHandler("/", noop);
try {
expect(await lpr.route("lens://app")).toBeUndefined();
} catch (error) {
expect(throwIfDefined(error)).not.toThrow();
}
expect(broadcastMessageMock).toHaveBeenCalledWith(ProtocolHandlerInternal, "lens://app", "matched");
});
it("should broadcast external route when called with valid host", async () => {
const extId = uuid.v4();
const ext = new LensExtension({
id: extId,

28
packages/core/src/main/protocol-handler/lens-protocol-router-main/lens-protocol-router-main.ts
View File

@ -6,7 +6,7 @@
import * as proto from "../../../common/protocol-handler";
import URLParse from "url-parse";
import type { LensExtension } from "../../../extensions/lens-extension";
import { observable, when, makeObservable } from "mobx";
import { observable, when } from "mobx";
import type { LensProtocolRouterDependencies, RouteAttempt } from "../../../common/protocol-handler";
import { ProtocolHandlerInvalid } from "../../../common/protocol-handler";
import { disposer, noop } from "@k8slens/utilities";
@ -39,17 +39,15 @@ export interface LensProtocolRouterMainDependencies extends LensProtocolRouterDe
}
export class LensProtocolRouterMain extends proto.LensProtocolRouter {
private missingExtensionHandlers: FallbackHandler[] = [];
private readonly missingExtensionHandlers: FallbackHandler[] = [];
// TODO: This is used to solve out-of-place temporal dependency. Remove, and solve otherwise.
@observable rendererLoaded = false;
readonly rendererLoaded = observable.box(false);
protected disposers = disposer();
protected readonly disposers = disposer();
constructor(protected readonly dependencies: LensProtocolRouterMainDependencies) {
super(dependencies);
makeObservable(this);
}
public cleanup() {
@ -118,13 +116,12 @@ export class LensProtocolRouterMain extends proto.LensProtocolRouter {
protected _routeToInternal(url: URLParse<Record<string, string | undefined>>): RouteAttempt {
const rawUrl = url.toString(); // for sending to renderer
const attempt = super._routeToInternal(url);
const broadcastToRenderer = () => this.dependencies.broadcastMessage(proto.ProtocolHandlerInternal, rawUrl, attempt);
const sendRoutingToRenderer = () => this.dependencies.broadcastMessage(proto.ProtocolHandlerInternal, rawUrl, attempt);
if (this.rendererLoaded) {
sendRoutingToRenderer();
if (this.rendererLoaded.get()) {
broadcastToRenderer();
} else {
this.disposers.push(when(() => this.rendererLoaded, sendRoutingToRenderer));
this.disposers.push(when(() => this.rendererLoaded.get(), broadcastToRenderer));
}
return attempt;
@ -141,13 +138,12 @@ export class LensProtocolRouterMain extends proto.LensProtocolRouter {
* argument.
*/
const attempt = await super._routeToExtension(new URLParse(url.toString(), true));
const broadcastToRenderer = () => this.dependencies.broadcastMessage(proto.ProtocolHandlerExtension, rawUrl, attempt);
const sendRoutingToRenderer = () => this.dependencies.broadcastMessage(proto.ProtocolHandlerExtension, rawUrl, attempt);
if (this.rendererLoaded) {
sendRoutingToRenderer();
if (this.rendererLoaded.get()) {
broadcastToRenderer();
} else {
this.disposers.push(when(() => this.rendererLoaded, sendRoutingToRenderer));
this.disposers.push(when(() => this.rendererLoaded.get(), broadcastToRenderer));
}
return attempt;

2
packages/core/src/main/start-main-application/runnables/flag-renderer/flag-renderer-as-loaded.injectable.ts
View File

@ -16,7 +16,7 @@ const flagRendererAsLoadedInjectable = getInjectable({
runInAction(() => {
// Todo: remove this kludge which enables out-of-place temporal dependency.
lensProtocolRouterMain.rendererLoaded = true;
lensProtocolRouterMain.rendererLoaded.set(true);
});
},
}),

2
packages/core/src/main/start-main-application/runnables/flag-renderer/flag-renderer-as-not-loaded.injectable.ts
View File

@ -16,7 +16,7 @@ const flagRendererAsNotLoadedInjectable = getInjectable({
runInAction(() => {
// Todo: remove this kludge which enables out-of-place temporal dependency.
lensProtocolRouterMain.rendererLoaded = false;
lensProtocolRouterMain.rendererLoaded.set(false);
});
return undefined;

0
packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/__snapshots__/hpa-details.test.tsx.snap → packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/__snapshots__/details.test.tsx.snap
View File

1
packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/hpa-details.scss → packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/details.scss
View File

@ -16,6 +16,7 @@
.TableCell {
word-break: break-word;
&:first-child {
margin-left: $margin * 2;
}

28
packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/hpa-details.test.tsx → packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/details.test.tsx
View File

@ -13,7 +13,7 @@ import { getDiForUnitTesting } from "../../getDiForUnitTesting";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import type { DiRender } from "../test-utils/renderFor";
import { renderFor } from "../test-utils/renderFor";
import { HpaDetails } from "./hpa-details";
import { HorizontalPodAutoscalerDetails } from "./details";
jest.mock("react-router-dom", () => ({
Link: ({ children }: { children: React.ReactNode }) => children,
@ -62,7 +62,7 @@ describe("<HpaDetails/>", () => {
const hpa = new HorizontalPodAutoscaler(hpaV2);
result = render(
<HpaDetails object={hpa} />,
<HorizontalPodAutoscalerDetails object={hpa} />,
);
expect(result.baseElement).toMatchSnapshot();
@ -72,7 +72,7 @@ describe("<HpaDetails/>", () => {
const hpa = new HorizontalPodAutoscaler(hpaV2);
result = render(
<HpaDetails object={hpa} />,
<HorizontalPodAutoscalerDetails object={hpa} />,
);
expect(result.queryByTestId("hpa-metrics")).toBeNull();
@ -101,7 +101,7 @@ describe("<HpaDetails/>", () => {
});
result = render(
<HpaDetails object={hpa} />,
<HorizontalPodAutoscalerDetails object={hpa} />,
);
expect(result.getByText("CPU Utilization percentage")).toBeInTheDocument();
@ -131,7 +131,7 @@ describe("<HpaDetails/>", () => {
);
result = render(
<HpaDetails object={hpa} />,
<HorizontalPodAutoscalerDetails object={hpa} />,
);
expect(result.getByText("Resource cpu on Pods")).toBeInTheDocument();
@ -160,7 +160,7 @@ describe("<HpaDetails/>", () => {
);
result = render(
<HpaDetails object={hpa} />,
<HorizontalPodAutoscalerDetails object={hpa} />,
);
expect(result.getByText("Resource cpu on Pods")).toBeInTheDocument();
@ -191,7 +191,7 @@ describe("<HpaDetails/>", () => {
);
result = render(
<HpaDetails object={hpa} />,
<HorizontalPodAutoscalerDetails object={hpa} />,
);
expect(result.getByText("packets-per-second on Pods")).toBeInTheDocument();
@ -216,7 +216,7 @@ describe("<HpaDetails/>", () => {
);
result = render(
<HpaDetails object={hpa} />,
<HorizontalPodAutoscalerDetails object={hpa} />,
);
expect(result.getByText("packets-per-second on Pods")).toBeInTheDocument();
@ -252,7 +252,7 @@ describe("<HpaDetails/>", () => {
);
result = render(
<HpaDetails object={hpa} />,
<HorizontalPodAutoscalerDetails object={hpa} />,
);
expect(result.getByText(/requests-per-second/)).toHaveTextContent("requests-per-second onService/nginx");
@ -277,7 +277,7 @@ describe("<HpaDetails/>", () => {
);
result = render(
<HpaDetails object={hpa} />,
<HorizontalPodAutoscalerDetails object={hpa} />,
);
expect(result.getByText("requests-per-second")).toBeInTheDocument();
@ -311,7 +311,7 @@ describe("<HpaDetails/>", () => {
);
result = render(
<HpaDetails object={hpa} />,
<HorizontalPodAutoscalerDetails object={hpa} />,
);
expect(result.getByText("queue_messages_ready on {\"matchLabels\":{\"queue\":\"worker_tasks\"}}")).toBeInTheDocument();
@ -339,7 +339,7 @@ describe("<HpaDetails/>", () => {
);
result = render(
<HpaDetails object={hpa} />,
<HorizontalPodAutoscalerDetails object={hpa} />,
);
expect(result.getByText("queue_messages_ready on {\"matchLabels\":{\"queue\":\"worker_tasks\"}}")).toBeInTheDocument();
@ -368,7 +368,7 @@ describe("<HpaDetails/>", () => {
);
result = render(
<HpaDetails object={hpa} />,
<HorizontalPodAutoscalerDetails object={hpa} />,
);
expect(result.baseElement).toMatchSnapshot();
@ -398,7 +398,7 @@ describe("<HpaDetails/>", () => {
);
result = render(
<HpaDetails object={hpa} />,
<HorizontalPodAutoscalerDetails object={hpa} />,
);
expect(result.baseElement).toMatchSnapshot();

10
packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/hpa-details.tsx → packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/details.tsx
View File

@ -3,7 +3,7 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import "./hpa-details.scss";
import "./details.scss";
import React from "react";
import { observer } from "mobx-react";
@ -22,8 +22,8 @@ import { withInjectables } from "@ogre-tools/injectable-react";
import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
import getDetailsUrlInjectable from "../kube-detail-params/get-details-url.injectable";
import loggerInjectable from "../../../common/logger.injectable";
import getHorizontalPodAutoscalerMetrics from "./get-hpa-metrics.injectable";
import { getMetricName } from "./get-hpa-metric-name";
import getHorizontalPodAutoscalerMetrics from "./get-metrics.injectable";
import { getMetricName } from "./get-metric-name";
export interface HpaDetailsProps extends KubeObjectDetailsProps<HorizontalPodAutoscaler> {
}
@ -36,7 +36,7 @@ interface Dependencies {
}
@observer
class NonInjectedHpaDetails extends React.Component<HpaDetailsProps & Dependencies> {
class NonInjectedHorizontalPodAutoscalerDetails extends React.Component<HpaDetailsProps & Dependencies> {
private renderTargetLink(target: HorizontalPodAutoscalerMetricTarget | undefined) {
if (!target) {
return null;
@ -177,7 +177,7 @@ class NonInjectedHpaDetails extends React.Component<HpaDetailsProps & Dependenci
}
}
export const HpaDetails = withInjectables<Dependencies, HpaDetailsProps>(NonInjectedHpaDetails, {
export const HorizontalPodAutoscalerDetails = withInjectables<Dependencies, HpaDetailsProps>(NonInjectedHorizontalPodAutoscalerDetails, {
getProps: (di, props) => ({
...props,
apiManager: di.inject(apiManagerInjectable),

0
packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/get-hpa-metric-name.ts → packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/get-metric-name.ts
View File

6
packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/get-hpa-metrics.injectable.ts → packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/get-metrics.injectable.ts
View File

@ -5,9 +5,9 @@
import { getInjectable } from "@ogre-tools/injectable";
import type { HorizontalPodAutoscaler, HorizontalPodAutoscalerMetricSpec, HorizontalPodAutoscalerMetricStatus } from "../../../common/k8s-api/endpoints";
import { HpaMetricType } from "../../../common/k8s-api/endpoints";
import { getMetricName } from "./get-hpa-metric-name";
import { HorizontalPodAutoscalerV1MetricParser } from "./hpa-v1-metric-parser";
import { HorizontalPodAutoscalerV2MetricParser } from "./hpa-v2-metric-parser";
import { getMetricName } from "./get-metric-name";
import { HorizontalPodAutoscalerV1MetricParser } from "./metric-parser-v1";
import { HorizontalPodAutoscalerV2MetricParser } from "./metric-parser-v2";
type Parser = HorizontalPodAutoscalerV1MetricParser | HorizontalPodAutoscalerV2MetricParser;

4
packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/index.ts
View File

@ -3,5 +3,5 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
export * from "./hpa";
export * from "./hpa-details";
export * from "./list-view";
export * from "./details";

0
packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/hpa.scss → packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/list-view.scss
View File

4
packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/hpa.tsx → packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/list-view.tsx
View File

@ -3,7 +3,7 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import "./hpa.scss";
import "./list-view.scss";
import React from "react";
import { observer } from "mobx-react";
@ -17,7 +17,7 @@ import { KubeObjectAge } from "../kube-object/age";
import type { HorizontalPodAutoscalerStore } from "./store";
import { withInjectables } from "@ogre-tools/injectable-react";
import horizontalPodAutoscalerStoreInjectable from "./store.injectable";
import getHorizontalPodAutoscalerMetrics from "./get-hpa-metrics.injectable";
import getHorizontalPodAutoscalerMetrics from "./get-metrics.injectable";
import { NamespaceSelectBadge } from "../+namespaces/namespace-select-badge";
enum columnId {

0
packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/hpa-v1-metric-parser.ts → packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/metric-parser-v1.ts
View File

0
packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/hpa-v2-metric-parser.ts → packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/metric-parser-v2.ts
View File

12
packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/horizontal-pod-autoscaler-metrics.test.ts → packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/metric-parser.test.ts
View File

@ -3,7 +3,7 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import type { DiContainer } from "@ogre-tools/injectable";
import getHorizontalPodAutoscalerMetrics from "./get-hpa-metrics.injectable";
import getHorizontalPodAutoscalerMetrics from "./get-metrics.injectable";
import { getDiForUnitTesting } from "../../getDiForUnitTesting";
import { HorizontalPodAutoscaler, HpaMetricType } from "../../../common/k8s-api/endpoints";
@ -658,10 +658,10 @@ describe("getHorizontalPodAutoscalerMetrics", () => {
],
},
});
expect(getMetrics(hpa)[0]).toEqual("10% / 50%");
});
it("should return correct resource metrics with current value", () => {
const hpa = new HorizontalPodAutoscaler({
...hpaV2Beta1,
@ -691,7 +691,7 @@ describe("getHorizontalPodAutoscalerMetrics", () => {
],
},
});
expect(getMetrics(hpa)[0]).toEqual("500m / 100m");
});
@ -787,7 +787,7 @@ describe("getHorizontalPodAutoscalerMetrics", () => {
type: HpaMetricType.Pods,
pods: {
metricName: "packets-per-second",
targetAverageValue: "1k",
},
},
@ -1038,7 +1038,7 @@ describe("getHorizontalPodAutoscalerMetrics", () => {
],
},
});
expect(getMetrics(hpa)[0]).toEqual("unknown / 50%");
});
});

2
packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/horizontal-pod-autoscalers-route-component.injectable.ts → packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/route-component.injectable.ts
View File

@ -5,7 +5,7 @@
import { getInjectable } from "@ogre-tools/injectable";
import { routeSpecificComponentInjectionToken } from "../../routes/route-specific-component-injection-token";
import horizontalPodAutoscalersRouteInjectable from "../../../common/front-end-routing/routes/cluster/config/horizontal-pod-autoscalers/horizontal-pod-autoscalers-route.injectable";
import { HorizontalPodAutoscalers } from "./hpa";
import { HorizontalPodAutoscalers } from "./list-view";
const horizontalPodAutoscalersRouteComponentInjectable = getInjectable({
id: "horizontal-pod-autoscalers-route-component",

0
packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/horizontal-pod-auto-scalers-sidebar-items.injectable.tsx → packages/core/src/renderer/components/+config-horizontal-pod-autoscalers/sidebar-items.injectable.tsx
View File

2
packages/core/src/renderer/components/+extensions/attempt-install/attempt-install.injectable.tsx
View File

@ -86,7 +86,7 @@ const attemptInstall = ({
}
const extensionFolder = getExtensionDestFolder(name);
const installedExtension = extensionLoader.getExtension(validatedRequest.id);
const installedExtension = extensionLoader.getExtensionById(validatedRequest.id);
if (installedExtension) {
const { version: oldVersion } = installedExtension.manifest;

2
packages/core/src/renderer/components/+extensions/attempt-install/unpack-extension.injectable.tsx
View File

@ -73,7 +73,7 @@ const unpackExtensionInjectable = getInjectable({
await fse.move(unpackedRootFolder, extensionFolder, { overwrite: true });
// wait for the loader has actually install it
await when(() => extensionLoader.userExtensions.has(id));
await when(() => extensionLoader.userExtensions.get().has(id));
// Enable installed extensions by default.
extensionLoader.setIsEnabled(id, true);

27
packages/core/src/renderer/components/+extensions/disable-extension.injectable.ts Normal file
View File

@ -0,0 +1,27 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import type { LensExtensionId } from "@k8slens/legacy-extensions";
import { getInjectable } from "@ogre-tools/injectable";
import extensionLoaderInjectable from "../../../extensions/extension-loader/extension-loader.injectable";
export type DisableExtension = (extId: LensExtensionId) => void;
const disableExtensionInjectable = getInjectable({
id: "disable-extension",
instantiate: (di): DisableExtension => {
const extensionLoader = di.inject(extensionLoaderInjectable);
return (extId) => {
const ext = extensionLoader.getExtensionById(extId);
if (ext && !ext.isBundled) {
ext.isEnabled = false;
}
};
},
});
export default disableExtensionInjectable;

18
packages/core/src/renderer/components/+extensions/disable-extension/disable-extension.injectable.ts
View File

@ -1,18 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import extensionLoaderInjectable from "../../../../extensions/extension-loader/extension-loader.injectable";
import { disableExtension } from "./disable-extension";
const disableExtensionInjectable = getInjectable({
id: "disable-extension",
instantiate: (di) =>
disableExtension({
extensionLoader: di.inject(extensionLoaderInjectable),
}),
});
export default disableExtensionInjectable;

20
packages/core/src/renderer/components/+extensions/disable-extension/disable-extension.ts
View File

@ -1,20 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import type { LensExtensionId } from "@k8slens/legacy-extensions";
import type { ExtensionLoader } from "../../../../extensions/extension-loader";
interface Dependencies {
extensionLoader: ExtensionLoader;
}
export const disableExtension =
({ extensionLoader }: Dependencies) =>
(id: LensExtensionId) => {
const extension = extensionLoader.getExtension(id);
if (extension) {
extension.isEnabled = false;
}
};

27
packages/core/src/renderer/components/+extensions/enable-extension.injectable.ts Normal file
View File

@ -0,0 +1,27 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import type { LensExtensionId } from "@k8slens/legacy-extensions";
import { getInjectable } from "@ogre-tools/injectable";
import extensionLoaderInjectable from "../../../extensions/extension-loader/extension-loader.injectable";
export type EnableExtension = (extId: LensExtensionId) => void;
const enableExtensionInjectable = getInjectable({
id: "enable-extension",
instantiate: (di): EnableExtension => {
const extensionLoader = di.inject(extensionLoaderInjectable);
return (extId) => {
const ext = extensionLoader.getExtensionById(extId);
if (ext && !ext.isBundled) {
ext.isEnabled = true;
}
};
},
});
export default enableExtensionInjectable;

18
packages/core/src/renderer/components/+extensions/enable-extension/enable-extension.injectable.ts
View File

@ -1,18 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import extensionLoaderInjectable from "../../../../extensions/extension-loader/extension-loader.injectable";
import { enableExtension } from "./enable-extension";
const enableExtensionInjectable = getInjectable({
id: "enable-extension",
instantiate: (di) =>
enableExtension({
extensionLoader: di.inject(extensionLoaderInjectable),
}),
});
export default enableExtensionInjectable;

20
packages/core/src/renderer/components/+extensions/enable-extension/enable-extension.ts
View File

@ -1,20 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import type { LensExtensionId } from "@k8slens/legacy-extensions";
import type { ExtensionLoader } from "../../../../extensions/extension-loader";
interface Dependencies {
extensionLoader: ExtensionLoader;
}
export const enableExtension =
({ extensionLoader }: Dependencies) =>
(id: LensExtensionId) => {
const extension = extensionLoader.getExtension(id);
if (extension) {
extension.isEnabled = true;
}
};

156
packages/core/src/renderer/components/+extensions/extensions.tsx
View File

@ -4,138 +4,66 @@
*/
import styles from "./extensions.module.scss";
import type { IComputedValue } from "mobx";
import {
makeObservable,
observable,
reaction,
when,
} from "mobx";
import { disposeOnUnmount, observer } from "mobx-react";
import React from "react";
import { DropFileInput } from "../input";
import { Install } from "./install";
import { ExtensionInstall } from "./install";
import { InstalledExtensions } from "./installed-extensions";
import { Notice } from "./notice";
import { SettingLayout } from "../layout/setting-layout";
import { docsUrl } from "../../../common/vars";
import { withInjectables } from "@ogre-tools/injectable-react";
import userExtensionsInjectable from "./user-extensions/user-extensions.injectable";
import enableExtensionInjectable from "./enable-extension/enable-extension.injectable";
import disableExtensionInjectable from "./disable-extension/disable-extension.injectable";
import type { ConfirmUninstallExtension } from "./confirm-uninstall-extension.injectable";
import confirmUninstallExtensionInjectable from "./confirm-uninstall-extension.injectable";
import type { InstallExtensionFromInput } from "./install-extension-from-input.injectable";
import installExtensionFromInputInjectable from "./install-extension-from-input.injectable";
import installFromSelectFileDialogInjectable from "./install-from-select-file-dialog.injectable";
import type { InstallOnDrop } from "./install-on-drop.injectable";
import installOnDropInjectable from "./install-on-drop.injectable";
import { supportedExtensionFormats } from "./supported-extension-formats";
import extensionInstallationStateStoreInjectable from "../../../extensions/extension-installation-state-store/extension-installation-state-store.injectable";
import type { ExtensionInstallationStateStore } from "../../../extensions/extension-installation-state-store/extension-installation-state-store";
import Gutter from "../gutter/gutter";
import type { InstalledExtension, LensExtensionId } from "@k8slens/legacy-extensions";
const ExtensionsNotice = () => (
<Notice className={styles.notice}>
<p>
{"Add new features via Lens Extensions. Check out the "}
<a
href={`${docsUrl}/extensions/lens-extensions`}
target="_blank"
rel="noreferrer"
>
docs
</a>
{" and list of "}
<a
href="https://github.com/lensapp/lens-extensions/blob/main/README.md"
target="_blank"
rel="noreferrer"
>
available extensions
</a>
.
</p>
</Notice>
);
interface Dependencies {
userExtensions: IComputedValue<InstalledExtension[]>;
enableExtension: (id: LensExtensionId) => void;
disableExtension: (id: LensExtensionId) => void;
confirmUninstallExtension: ConfirmUninstallExtension;
installExtensionFromInput: InstallExtensionFromInput;
installFromSelectFileDialog: () => Promise<void>;
installOnDrop: InstallOnDrop;
extensionInstallationStateStore: ExtensionInstallationStateStore;
}
@observer
class NonInjectedExtensions extends React.Component<Dependencies> {
@observable installPath = "";
constructor(props: Dependencies) {
super(props);
makeObservable(this);
}
componentDidMount() {
disposeOnUnmount(this, [
reaction(() => this.props.userExtensions.get().length, (curSize, prevSize) => {
if (curSize > prevSize) {
disposeOnUnmount(this, [
when(() => !this.props.extensionInstallationStateStore.anyInstalling, () => this.installPath = ""),
]);
}
}),
]);
}
render() {
const userExtensions = this.props.userExtensions.get();
return (
<DropFileInput onDropFiles={this.props.installOnDrop}>
<SettingLayout
className="Extensions"
contentGaps={false}
data-testid="extensions-page"
>
<section>
<h1>Extensions</h1>
<Notice className={styles.notice}>
<p>
{"Add new features via Lens Extensions. Check out the "}
<a
href={`${docsUrl}/extensions/`}
target="_blank"
rel="noreferrer"
>
docs
</a>
{" and list of "}
<a
href="https://github.com/lensapp/lens-extensions/blob/main/README.md"
target="_blank"
rel="noreferrer"
>
available extensions
</a>
.
</p>
</Notice>
<Install
supportedFormats={supportedExtensionFormats}
onChange={value => (this.installPath = value)}
installFromInput={() => this.props.installExtensionFromInput(this.installPath)}
installFromSelectFileDialog={this.props.installFromSelectFileDialog}
installPath={this.installPath}
/>
<Gutter size="md" />
<InstalledExtensions
extensions={userExtensions}
enable={this.props.enableExtension}
disable={this.props.disableExtension}
uninstall={this.props.confirmUninstallExtension}
/>
</section>
</SettingLayout>
</DropFileInput>
);
}
}
const NonInjectedExtensions = ({ installOnDrop }: Dependencies) => (
<DropFileInput onDropFiles={installOnDrop}>
<SettingLayout
className="Extensions"
contentGaps={false}
data-testid="extensions-page"
>
<section>
<h1>Extensions</h1>
<ExtensionsNotice />
<ExtensionInstall />
<Gutter size="md" />
<InstalledExtensions />
</section>
</SettingLayout>
</DropFileInput>
);
export const Extensions = withInjectables<Dependencies>(NonInjectedExtensions, {
getProps: (di) => ({
userExtensions: di.inject(userExtensionsInjectable),
enableExtension: di.inject(enableExtensionInjectable),
disableExtension: di.inject(disableExtensionInjectable),
confirmUninstallExtension: di.inject(confirmUninstallExtensionInjectable),
installExtensionFromInput: di.inject(installExtensionFromInputInjectable),
installOnDrop: di.inject(installOnDropInjectable),
installFromSelectFileDialog: di.inject(installFromSelectFileDialogInjectable),
extensionInstallationStateStore: di.inject(extensionInstallationStateStoreInjectable),
}),
});

153
packages/core/src/renderer/components/+extensions/install.tsx
View File

@ -4,7 +4,7 @@
*/
import styles from "./install.module.scss";
import React from "react";
import React, { useEffect, useRef, useState } from "react";
import { prevDefault } from "@k8slens/utilities";
import { Button } from "../button";
import { Icon } from "../icon";
@ -16,17 +16,16 @@ import type { ExtensionInstallationStateStore } from "../../../extensions/extens
import extensionInstallationStateStoreInjectable from "../../../extensions/extension-installation-state-store/extension-installation-state-store.injectable";
import { withInjectables } from "@ogre-tools/injectable-react";
import { unionInputValidatorsAsync } from "../input/input_validators";
export interface InstallProps {
installPath: string;
supportedFormats: string[];
onChange: (path: string) => void;
installFromInput: () => void;
installFromSelectFileDialog: () => void;
}
import { supportedExtensionFormats } from "./supported-extension-formats";
import type { InstallExtensionFromInput } from "./install-extension-from-input.injectable";
import type { InstallFromSelectFileDialog } from "./install-from-select-file-dialog.injectable";
import installExtensionFromInputInjectable from "./install-extension-from-input.injectable";
import installFromSelectFileDialogInjectable from "./install-from-select-file-dialog.injectable";
interface Dependencies {
extensionInstallationStateStore: ExtensionInstallationStateStore;
installState: ExtensionInstallationStateStore;
installExtensionFromInput: InstallExtensionFromInput;
installFromSelectFileDialog: InstallFromSelectFileDialog;
}
const installInputValidator = unionInputValidatorsAsync(
@ -38,71 +37,75 @@ const installInputValidator = unionInputValidatorsAsync(
InputValidators.isPath,
);
const NonInjectedInstall: React.FC<Dependencies & InstallProps> = ({
installPath,
supportedFormats,
onChange,
installFromInput,
const installTitle = `Name or file path or URL to an extension package (${supportedExtensionFormats.join(", ")})`;
const NonInjectedInstall = observer(({
installExtensionFromInput,
installFromSelectFileDialog,
extensionInstallationStateStore,
}) => (
<section>
<SubTitle
title={`Name or file path or URL to an extension package (${supportedFormats.join(
", ",
)})`}
/>
<div className={styles.inputs}>
<div>
<Input
theme="round-black"
disabled={extensionInstallationStateStore.anyPreInstallingOrInstalling}
placeholder={"Name or file path or URL"}
showErrorsAsTooltip={{ preferredPositions: TooltipPosition.BOTTOM }}
validators={installPath ? installInputValidator : undefined}
value={installPath}
onChange={onChange}
onSubmit={installFromInput}
iconRight={(
<Icon
className={styles.icon}
smallest
material="folder_open"
onClick={prevDefault(installFromSelectFileDialog)}
tooltip="Browse"
/>
)}
/>
</div>
<div>
<Button
className={styles.button}
primary
label="Install"
disabled={
extensionInstallationStateStore.anyPreInstallingOrInstalling
}
waiting={extensionInstallationStateStore.anyPreInstallingOrInstalling}
onClick={installFromInput}
/>
</div>
</div>
<small className={styles.proTip}>
<b>Pro-Tip</b>
: you can drag and drop a tarball file to this area
</small>
</section>
);
installState,
}: Dependencies) => {
const [installPath, setInstallPath] = useState("");
const prevAnyInstalling = useRef(installState.anyInstalling);
export const Install = withInjectables<Dependencies, InstallProps>(
observer(NonInjectedInstall),
{
getProps: (di, props) => ({
extensionInstallationStateStore: di.inject(
extensionInstallationStateStoreInjectable,
),
useEffect(() => {
const currentlyInstalling = installState.anyInstalling;
const previouslyInstalling = prevAnyInstalling.current;
...props,
}),
},
);
if (!currentlyInstalling && previouslyInstalling) {
prevAnyInstalling.current = false;
setInstallPath("");
}
}, [installState.anyInstalling]);
return (
<section>
<SubTitle title={installTitle} />
<div className={styles.inputs}>
<div>
<Input
theme="round-black"
disabled={installState.anyPreInstallingOrInstalling}
placeholder="Name or file path or URL"
showErrorsAsTooltip={{ preferredPositions: TooltipPosition.BOTTOM }}
validators={installPath ? installInputValidator : undefined}
value={installPath}
onChange={setInstallPath}
onSubmit={() => installExtensionFromInput(installPath)}
iconRight={(
<Icon
className={styles.icon}
smallest
material="folder_open"
onClick={prevDefault(installFromSelectFileDialog)}
tooltip="Browse"
/>
)}
/>
</div>
<div>
<Button
className={styles.button}
primary
label="Install"
disabled={installState.anyPreInstallingOrInstalling}
waiting={installState.anyPreInstallingOrInstalling}
onClick={() => installExtensionFromInput(installPath)}
/>
</div>
</div>
<small className={styles.proTip}>
<b>Pro-Tip</b>
: you can drag and drop a tarball file to this area
</small>
</section>
);
});
export const ExtensionInstall = withInjectables<Dependencies>(NonInjectedInstall, {
getProps: (di, props) => ({
...props,
installState: di.inject(extensionInstallationStateStoreInjectable),
installExtensionFromInput: di.inject(installExtensionFromInputInjectable),
installFromSelectFileDialog: di.inject(installFromSelectFileDialogInjectable),
}),
});

223
packages/core/src/renderer/components/+extensions/installed-extensions.tsx
View File

@ -4,8 +4,7 @@
*/
import styles from "./installed-extensions.module.scss";
import React, { useMemo } from "react";
import type { ExtensionDiscovery } from "../../../extensions/extension-discovery/extension-discovery";
import React from "react";
import { Icon } from "../icon";
import { List } from "../list/list";
import { MenuActions, MenuItem } from "../menu";
@ -17,18 +16,27 @@ import extensionDiscoveryInjectable from "../../../extensions/extension-discover
import { withInjectables } from "@ogre-tools/injectable-react";
import extensionInstallationStateStoreInjectable from "../../../extensions/extension-installation-state-store/extension-installation-state-store.injectable";
import type { ExtensionInstallationStateStore } from "../../../extensions/extension-installation-state-store/extension-installation-state-store";
import type { InstalledExtension, LensExtensionId } from "@k8slens/legacy-extensions";
import type { InstalledExtension } from "@k8slens/legacy-extensions";
import type { IComputedValue } from "mobx";
import type { ConfirmUninstallExtension } from "./confirm-uninstall-extension.injectable";
import confirmUninstallExtensionInjectable from "./confirm-uninstall-extension.injectable";
import type { DisableExtension } from "./disable-extension.injectable";
import disableExtensionInjectable from "./disable-extension.injectable";
import type { EnableExtension } from "./enable-extension.injectable";
import enableExtensionInjectable from "./enable-extension.injectable";
import userExtensionsInjectable from "./user-extensions/user-extensions.injectable";
import type { ExtensionDiscovery } from "../../../extensions/extension-discovery/extension-discovery";
export interface InstalledExtensionsProps {
extensions: InstalledExtension[];
enable: (id: LensExtensionId) => void;
disable: (id: LensExtensionId) => void;
uninstall: (extension: InstalledExtension) => void;
}
interface Dependencies {
extensionDiscovery: ExtensionDiscovery;
extensionInstallationStateStore: ExtensionInstallationStateStore;
userExtensions: IComputedValue<InstalledExtension[]>;
enableExtension: EnableExtension;
disableExtension: DisableExtension;
confirmUninstallExtension: ConfirmUninstallExtension;
}
function getStatus(extension: InstalledExtension) {
@ -39,106 +47,20 @@ function getStatus(extension: InstalledExtension) {
return extension.isEnabled ? "Enabled" : "Disabled";
}
const NonInjectedInstalledExtensions = observer(({ extensionDiscovery, extensionInstallationStateStore, extensions, uninstall, enable, disable }: Dependencies & InstalledExtensionsProps) => {
const columns = useMemo(
() => [
{
Header: "Name",
accessor: "extension",
width: 200,
sortType: (rowA: Row, rowB: Row) => { // Custom sorting for extension name
const nameA = extensions[rowA.index].manifest.name;
const nameB = extensions[rowB.index].manifest.name;
if (nameA > nameB) return -1;
if (nameB > nameA) return 1;
return 0;
},
},
{
Header: "Version",
accessor: "version",
},
{
Header: "Status",
accessor: "status",
},
{
Header: "",
accessor: "actions",
disableSortBy: true,
width: 20,
className: "actions",
},
], [],
);
const data = useMemo(
() => extensions.map(extension => {
const { id, isEnabled, isCompatible, manifest } = extension;
const { name, description, version } = manifest;
const isUninstalling = extensionInstallationStateStore.isExtensionUninstalling(id);
return {
extension: (
<div className={"flex items-start"}>
<div>
<div className={styles.extensionName}>{name}</div>
<div className={styles.extensionDescription}>{description}</div>
</div>
</div>
),
version,
status: (
<div className={cssNames({ [styles.enabled]: isEnabled, [styles.invalid]: !isCompatible })}>
{getStatus(extension)}
</div>
),
actions: (
<MenuActions
id={`menu-actions-for-installed-extensions-for-${id}`}
usePortal
toolbar={false}>
{isCompatible && (
<>
{isEnabled ? (
<MenuItem
disabled={isUninstalling}
onClick={() => disable(id)}
>
<Icon material="unpublished" />
<span className="title" aria-disabled={isUninstalling}>Disable</span>
</MenuItem>
) : (
<MenuItem
disabled={isUninstalling}
onClick={() => enable(id)}
>
<Icon material="check_circle" />
<span className="title" aria-disabled={isUninstalling}>Enable</span>
</MenuItem>
)}
</>
)}
<MenuItem
disabled={isUninstalling}
onClick={() => uninstall(extension)}
>
<Icon material="delete" />
<span className="title" aria-disabled={isUninstalling}>Uninstall</span>
</MenuItem>
</MenuActions>
),
};
}), [extensions, extensionInstallationStateStore.anyUninstalling],
);
const NonInjectedInstalledExtensions = observer(({
extensionDiscovery,
extensionInstallationStateStore,
userExtensions,
confirmUninstallExtension,
enableExtension,
disableExtension,
}: Dependencies & InstalledExtensionsProps) => {
if (!extensionDiscovery.isLoaded) {
return <div><Spinner center /></div>;
}
const extensions = userExtensions.get();
if (extensions.length == 0) {
return (
<div className="flex column h-full items-center justify-center">
@ -151,13 +73,96 @@ const NonInjectedInstalledExtensions = observer(({ extensionDiscovery, extension
);
}
const toggleExtensionWith = (enabled: boolean) => (
enabled
? disableExtension
: enableExtension
);
return (
<section data-testid="extensions-table">
<List
title={<h2 className={styles.title}>Installed extensions</h2>}
columns={columns}
data={data}
items={extensions}
columns={[
{
Header: "Name",
accessor: "extension",
width: 200,
sortType: (rowA: Row, rowB: Row) => { // Custom sorting for extension name
const nameA = extensions[rowA.index].manifest.name;
const nameB = extensions[rowB.index].manifest.name;
if (nameA > nameB) return -1;
if (nameB > nameA) return 1;
return 0;
},
},
{
Header: "Version",
accessor: "version",
},
{
Header: "Status",
accessor: "status",
},
{
Header: "",
accessor: "actions",
disableSortBy: true,
width: 20,
},
]}
data={extensions.map(extension => {
const { id, isEnabled, isCompatible, manifest } = extension;
const { name, description, version } = manifest;
const isUninstalling = extensionInstallationStateStore.isExtensionUninstalling(id);
const toggleExtension = toggleExtensionWith(isEnabled);
return {
extension: (
<div className={"flex items-start"}>
<div>
<div className={styles.extensionName}>{name}</div>
<div className={styles.extensionDescription}>{description}</div>
</div>
</div>
),
version,
status: (
<div className={cssNames({ [styles.enabled]: isEnabled, [styles.invalid]: !isCompatible })}>
{getStatus(extension)}
</div>
),
actions: (
<MenuActions
id={`menu-actions-for-installed-extensions-for-${id}`}
usePortal
toolbar={false}>
{isCompatible && (
<MenuItem
disabled={isUninstalling}
onClick={() => toggleExtension(id)}
>
<Icon material={isEnabled ? "unpublished" : "check_circle"} />
<span className="title" aria-disabled={isUninstalling}>
{isEnabled ? "Disable" : "Enabled"}
</span>
</MenuItem>
)}
<MenuItem
disabled={isUninstalling}
onClick={() => confirmUninstallExtension(extension)}
>
<Icon material="delete" />
<span className="title" aria-disabled={isUninstalling}>Uninstall</span>
</MenuItem>
</MenuActions>
),
};
})}
items={userExtensions.get()}
filters={[
(extension) => extension.manifest.name,
(extension) => getStatus(extension),
@ -170,8 +175,12 @@ const NonInjectedInstalledExtensions = observer(({ extensionDiscovery, extension
export const InstalledExtensions = withInjectables<Dependencies, InstalledExtensionsProps>(NonInjectedInstalledExtensions, {
getProps: (di, props) => ({
...props,
extensionDiscovery: di.inject(extensionDiscoveryInjectable),
extensionInstallationStateStore: di.inject(extensionInstallationStateStoreInjectable),
...props,
userExtensions: di.inject(userExtensionsInjectable),
enableExtension: di.inject(enableExtensionInjectable),
disableExtension: di.inject(disableExtensionInjectable),
confirmUninstallExtension: di.inject(confirmUninstallExtensionInjectable),
}),
});

4
packages/core/src/renderer/components/+extensions/uninstall-extension.injectable.tsx
View File

@ -27,7 +27,7 @@ const uninstallExtensionInjectable = getInjectable({
const showErrorNotification = di.inject(showErrorNotificationInjectable);
return async (extensionId: LensExtensionId): Promise<boolean> => {
const ext = extensionLoader.getExtension(extensionId);
const ext = extensionLoader.getExtensionById(extensionId);
if (!ext) {
logger.debug(`[EXTENSIONS]: cannot uninstall ${extensionId}, was not installed`);
@ -45,7 +45,7 @@ const uninstallExtensionInjectable = getInjectable({
await extensionDiscovery.uninstallExtension(extensionId);
// wait for the ExtensionLoader to actually uninstall the extension
await when(() => !extensionLoader.userExtensions.has(extensionId));
await when(() => !extensionLoader.userExtensions.get().has(extensionId));
showSuccessNotification(
<p>

2
packages/core/src/renderer/components/+extensions/user-extensions/user-extensions.injectable.ts
View File

@ -12,7 +12,7 @@ const userExtensionsInjectable = getInjectable({
instantiate: (di) => {
const extensionLoader = di.inject(extensionLoaderInjectable);
return computed(() => [...extensionLoader.userExtensions.values()]);
return computed(() => [...extensionLoader.userExtensions.get().values()]);
},
});

27
packages/core/src/renderer/components/dock/edit-resource/edit-resource-model/call-for-resource/call-for-resource.injectable.ts
View File

@ -3,44 +3,35 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import type { KubeObject } from "../../../../../../common/k8s-api/kube-object";
import { KubeObject } from "../../../../../../common/k8s-api/kube-object";
import { parseKubeApi } from "../../../../../../common/k8s-api/kube-api-parse";
import type { AsyncResult } from "@k8slens/utilities";
import { getErrorMessage } from "../../../../../../common/utils/get-error-message";
import apiManagerInjectable from "../../../../../../common/k8s-api/api-manager/manager.injectable";
import { waitUntilDefined } from "@k8slens/utilities";
import apiKubeInjectable from "../../../../../k8s/api-kube.injectable";
export type CallForResource = (
selfLink: string
) => AsyncResult<KubeObject | undefined>;
export type CallForResource = (selfLink: string) => AsyncResult<KubeObject | undefined>;
const callForResourceInjectable = getInjectable({
id: "call-for-resource",
instantiate: (di): CallForResource => {
const apiManager = di.inject(apiManagerInjectable);
const apiKube = di.inject(apiKubeInjectable);
return async (apiPath: string) => {
const api = await waitUntilDefined(() => apiManager.getApi(apiPath));
const parsed = parseKubeApi(apiPath);
if (!api || !parsed.name) {
if (!parsed.name) {
return { callWasSuccessful: false, error: "Invalid API path" };
}
let resource: KubeObject | null;
try {
resource = await api.get({
name: parsed.name,
namespace: parsed.namespace,
});
return {
callWasSuccessful: true,
response: new KubeObject(await apiKube.get(apiPath)),
};
} catch (e) {
return { callWasSuccessful: false, error: getErrorMessage(e) };
}
return { callWasSuccessful: true, response: resource || undefined };
};
},

116
packages/core/src/renderer/components/dock/edit-resource/edit-resource-model/edit-resource-model.injectable.tsx
View File

@ -7,9 +7,9 @@ import type { CallForResource } from "./call-for-resource/call-for-resource.inje
import callForResourceInjectable from "./call-for-resource/call-for-resource.injectable";
import { waitUntilDefined } from "@k8slens/utilities";
import editResourceTabStoreInjectable from "../store.injectable";
import type { EditResourceTabStore } from "../store";
import { action, computed, makeObservable, observable, runInAction } from "mobx";
import type { KubeObject } from "../../../../../common/k8s-api/kube-object";
import type { EditingResource, EditResourceTabStore } from "../store";
import { action, computed, observable, runInAction } from "mobx";
import type { KubeObject, RawKubeObject } from "../../../../../common/k8s-api/kube-object";
import yaml from "js-yaml";
import assert from "assert";
import type { CallForPatchResource } from "./call-for-patch-resource/call-for-patch-resource.injectable";
@ -19,18 +19,22 @@ import type { ShowNotification } from "../../../notifications";
import showSuccessNotificationInjectable from "../../../notifications/show-success-notification.injectable";
import React from "react";
import showErrorNotificationInjectable from "../../../notifications/show-error-notification.injectable";
import { createKubeApiURL, parseKubeApi } from "../../../../../common/k8s-api/kube-api-parse";
const editResourceModelInjectable = getInjectable({
id: "edit-resource-model",
instantiate: async (di, tabId: string) => {
const store = di.inject(editResourceTabStoreInjectable);
const model = new EditResourceModel({
callForResource: di.inject(callForResourceInjectable),
callForPatchResource: di.inject(callForPatchResourceInjectable),
showSuccessNotification: di.inject(showSuccessNotificationInjectable),
showErrorNotification: di.inject(showErrorNotificationInjectable),
store: di.inject(editResourceTabStoreInjectable),
store,
tabId,
waitForEditingResource: () => waitUntilDefined(() => store.getData(tabId)),
});
await model.load();
@ -48,19 +52,42 @@ export default editResourceModelInjectable;
interface Dependencies {
callForResource: CallForResource;
callForPatchResource: CallForPatchResource;
waitForEditingResource: () => Promise<EditingResource>;
showSuccessNotification: ShowNotification;
showErrorNotification: ShowNotification;
readonly store: EditResourceTabStore;
readonly tabId: string;
}
export class EditResourceModel {
constructor(private readonly dependencies: Dependencies) {
makeObservable(this);
function getEditSelfLinkFor(object: RawKubeObject): string {
const lensVersionLabel = object.metadata.labels?.[EditResourceLabelName];
if (lensVersionLabel) {
const { apiVersionWithGroup, ...parsedApi } = parseKubeApi(object.metadata.selfLink);
parsedApi.apiVersion = lensVersionLabel;
return createKubeApiURL({
...parsedApi,
apiVersion: `${parsedApi.apiGroup}/${parsedApi.apiVersion}`,
});
}
return object.metadata.selfLink;
}
/**
* The label name that Lens uses to receive the desired api version
*/
export const EditResourceLabelName = "k8slens-edit-resource-version";
export class EditResourceModel {
constructor(protected readonly dependencies: Dependencies) {}
readonly configuration = {
value: computed(() => this.editingResource.draft || this.editingResource.firstDraft || ""),
value: computed(
() => this.editingResource.draft || this.editingResource.firstDraft || "",
),
onChange: action((value: string) => {
this.editingResource.draft = value;
@ -100,27 +127,39 @@ export class EditResourceModel {
return this.editingResource.resource;
}
load = async () => {
await waitUntilDefined(() => this.dependencies.store.getData(this.dependencies.tabId));
load = async (): Promise<void> => {
await this.dependencies.waitForEditingResource();
const result = await this.dependencies.callForResource(this.selfLink);
let result = await this.dependencies.callForResource(this.selfLink);
if (!result.callWasSuccessful) {
this.dependencies.showErrorNotification(
`Loading resource failed: ${result.error}`,
);
return void this.dependencies.showErrorNotification(`Loading resource failed: ${result.error}`);
}
if (result?.response?.metadata.labels?.[EditResourceLabelName]) {
const parsed = parseKubeApi(this.selfLink);
parsed.apiVersion = result.response.metadata.labels[EditResourceLabelName];
result = await this.dependencies.callForResource(createKubeApiURL(parsed));
}
if (!result.callWasSuccessful) {
return void this.dependencies.showErrorNotification(`Loading resource failed: ${result.error}`);
}
const resource = result.response;
runInAction(() => {
this._resource = resource;
});
if (!resource) {
return;
}
runInAction(() => {
this._resource = result.response;
if (this._resource) {
this.editingResource.firstDraft = yaml.dump(
this._resource.toPlainObject(),
);
}
this.editingResource.firstDraft = yaml.dump(resource.toPlainObject());
});
};
@ -138,16 +177,16 @@ export class EditResourceModel {
save = async () => {
const currentValue = this.configuration.value.get();
const currentVersion = yaml.load(currentValue);
const firstVersion = yaml.load(
this.editingResource.firstDraft ?? currentValue,
);
const patches = createPatch(firstVersion, currentVersion);
const currentVersion = yaml.load(currentValue) as RawKubeObject;
const firstVersion = yaml.load(this.editingResource.firstDraft ?? currentValue);
const result = await this.dependencies.callForPatchResource(
this.resource,
patches,
);
// Make sure we save this label so that we can use it in the future
currentVersion.metadata.labels ??= {};
currentVersion.metadata.labels[EditResourceLabelName] = currentVersion.apiVersion.split("/").pop();
const patches = createPatch(firstVersion, currentVersion);
const selfLink = getEditSelfLinkFor(currentVersion);
const result = await this.dependencies.callForPatchResource(this.resource, patches);
if (!result.callWasSuccessful) {
this.dependencies.showErrorNotification((
@ -158,23 +197,26 @@ export class EditResourceModel {
</p>
));
return;
return null;
}
const { kind, name } = result.response;
this.dependencies.showSuccessNotification((
this.dependencies.showSuccessNotification(
<p>
{`${kind} `}
{kind}
{" "}
<b>{name}</b>
{" updated."}
</p>
));
</p>,
);
runInAction(() => {
this.editingResource.firstDraft = currentValue;
this.editingResource.firstDraft = yaml.dump(currentVersion);
this.editingResource.resource = selfLink;
});
return result.response.toString();
// NOTE: This is required for `saveAndClose` to work correctly
return [];
};
}

6
packages/core/src/renderer/components/dock/edit-resource/view.tsx
View File

@ -56,12 +56,14 @@ const NonInjectedEditResource = observer(({
<span>Namespace:</span>
<Badge label={model.namespace} />
</div>
)} />
)}
/>
<EditorPanel
tabId={tabId}
value={model.configuration.value.get()}
onChange={model.configuration.onChange}
onError={model.configuration.error.onChange} />
onError={model.configuration.error.onChange}
/>
</>
)
}

4
packages/core/src/renderer/components/kube-object-details/kube-object-detail-items/implementations/horizontal-pod-autoscaler-detail-item.injectable.ts
View File

@ -4,7 +4,7 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import { kubeObjectDetailItemInjectionToken } from "../kube-object-detail-item-injection-token";
import { HpaDetails } from "../../../+config-horizontal-pod-autoscalers";
import { HorizontalPodAutoscalerDetails } from "../../../+config-horizontal-pod-autoscalers";
import { computed } from "mobx";
import { kubeObjectMatchesToKindAndApiVersion } from "../kube-object-matches-to-kind-and-api-version";
import currentKubeObjectInDetailsInjectable from "../../current-kube-object-in-details.injectable";
@ -16,7 +16,7 @@ const horizontalPodAutoscalerDetailItemInjectable = getInjectable({
const kubeObject = di.inject(currentKubeObjectInDetailsInjectable);
return {
Component: HpaDetails,
Component: HorizontalPodAutoscalerDetails,
enabled: computed(() => isHorizontalPodAutoscaler(kubeObject.value.get()?.object)),
orderNumber: 10,
};

8
packages/core/src/renderer/components/monaco-editor/monaco-editor.tsx
View File

@ -246,12 +246,10 @@ class NonInjectedMonacoEditor extends React.Component<MonacoEditorProps & Depend
this.dispose.push(
reaction(() => this.model, this.onModelChange),
reaction(() => this.theme, theme => {
if (theme) {
editor.setTheme(theme);
}
reaction(() => this.theme, editor.setTheme),
reaction(() => this.props.value, value => this.setValue(value), {
fireImmediately: true,
}),
reaction(() => this.props.value, value => this.setValue(value)),
reaction(() => this.options, opts => this.editor.updateOptions(opts)),
() => onDidLayoutChangeDisposer.dispose(),

2
packages/core/src/renderer/extension-loader/create-extension-instance.injectable.ts
View File

@ -30,7 +30,7 @@ const createExtensionInstanceInjectable = getInjectable({
};
return (ExtensionClass, extension) => {
const instance = new ExtensionClass(extension) as LensRendererExtension;
const instance = new ExtensionClass(extension as any) as LensRendererExtension;
(instance as Writable<LensRendererExtension>)[lensExtensionDependencies] = deps;

4
packages/core/src/common/vars/application-information-fake.injectable.testing-env.ts → packages/core/src/test-env/application-information-fake.injectable.ts
View File

@ -18,9 +18,7 @@ export const applicationInformationFakeInjectable = getInjectable({
bundledKubectlVersion: "1.23.3",
bundledHelmVersion: "3.7.2",
sentryDsn: "",
contentSecurityPolicy:
"script-src 'unsafe-eval' 'self'; frame-src http://*.localhost:*/; img-src * data:",
contentSecurityPolicy: "script-src 'unsafe-eval' 'self'; frame-src http://*.localhost:*/; img-src * data:",
welcomeRoute: "/welcome",
copyright: "some-copyright-information",
description: "some-descriptive-text",

8
packages/core/src/common/vars/node-env.injectable.testing-env.ts → packages/core/src/test-env/node-env.injectable.ts
View File

@ -3,12 +3,12 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import { nodeEnvInjectionToken } from "./node-env-injection-token";
import { nodeEnvInjectionToken } from "../main/library";
const nodeEnvFakeInjectable = getInjectable({
id: "node-env-fake",
const nodeEnvForTestingEnvInjectable = getInjectable({
id: "node-env-for-testing-env",
instantiate: () => "production",
injectionToken: nodeEnvInjectionToken,
});
export default nodeEnvFakeInjectable;
export default nodeEnvForTestingEnvInjectable;

5
packages/core/webpack/main.ts
View File

@ -10,7 +10,6 @@ import ForkTsCheckerPlugin from "fork-ts-checker-webpack-plugin";
import { iconsAndImagesWebpackRules } from "./renderer";
import { DefinePlugin } from "webpack";
import { buildDir, isDevelopment } from "./vars";
import { platform } from "process";
const webpackLensMain = (): webpack.Configuration => {
return {
@ -67,8 +66,8 @@ const webpackLensMain = (): webpack.Configuration => {
},
plugins: [
new DefinePlugin({
CONTEXT_MATCHER_FOR_NON_FEATURES: `/\\.injectable(\\.${platform})?\\.tsx?$/`,
CONTEXT_MATCHER_FOR_FEATURES: `/\\/(main|common)\\/.+\\.injectable(\\.${platform})?\\.tsx?$/`,
CONTEXT_MATCHER_FOR_NON_FEATURES: `/\\.injectable\\.tsx?$/`,
CONTEXT_MATCHER_FOR_FEATURES: `/\\/(main|common)\\/.+\\.injectable\\.tsx?$/`,
}),
new ForkTsCheckerPlugin({
typescript: {

5
packages/core/webpack/renderer.ts
View File

@ -12,7 +12,6 @@ import type { WebpackPluginInstance } from "webpack";
import { optimize, DefinePlugin } from "webpack";
import nodeExternals from "webpack-node-externals";
import { isDevelopment, buildDir, sassCommonVars } from "./vars";
import { platform } from "process";
export function webpackLensRenderer(): webpack.Configuration {
return {
@ -84,8 +83,8 @@ export function webpackLensRenderer(): webpack.Configuration {
plugins: [
new DefinePlugin({
CONTEXT_MATCHER_FOR_NON_FEATURES: `/\\.injectable(\\.${platform})?\\.tsx?$/`,
CONTEXT_MATCHER_FOR_FEATURES: `/\\/(renderer|common)\\/.+\\.injectable(\\.${platform})?\\.tsx?$/`,
CONTEXT_MATCHER_FOR_NON_FEATURES: `/\\.injectable\\.tsx?$/`,
CONTEXT_MATCHER_FOR_FEATURES: `/\\/(renderer|common)\\/.+\\.injectable\\.tsx?$/`,
}),
new ForkTsCheckerPlugin({}),

2
packages/infrastructure/eslint-config/prettier-config.json
View File

@ -1,5 +1,5 @@
{
"printWidth": 100,
"printWidth": 120,
"tabWidth": 2,
"useTabs": false,
"semi": true,

14
packages/open-lens/src/common/build-environment.injectable.ts Normal file
View File

@ -0,0 +1,14 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { lensBuildEnvironmentInjectionToken } from "@k8slens/application";
import { getInjectable } from "@ogre-tools/injectable";
const lensBuildEnvironmentInjectable = getInjectable({
id: "lens-build-environment",
instantiate: () => "unknown",
injectionToken: lensBuildEnvironmentInjectionToken,
});
export default lensBuildEnvironmentInjectable;

4
packages/open-lens/webpack/main.ts
View File

@ -50,8 +50,8 @@ const main: webpack.Configuration = ({
},
plugins: [
new DefinePlugin({
CONTEXT_MATCHER_FOR_NON_FEATURES: `/\\.injectable(\\.${platform})?\\.tsx?$/`,
CONTEXT_MATCHER_FOR_FEATURES: `/\\/(renderer|common)\\/.+\\.injectable(\\.${platform})?\\.tsx?$/`,
CONTEXT_MATCHER_FOR_NON_FEATURES: `/\\.injectable\\.tsx?$/`,
CONTEXT_MATCHER_FOR_FEATURES: `/\\/(renderer|common)\\/.+\\.injectable\\.tsx?$/`,
}),
],
});

4
packages/open-lens/webpack/renderer.ts
View File

@ -81,8 +81,8 @@
plugins: [
new DefinePlugin({
CONTEXT_MATCHER_FOR_NON_FEATURES: `/\\.injectable(\\.${platform})?\\.tsx?$/`,
CONTEXT_MATCHER_FOR_FEATURES: `/\\/(renderer|common)\\/.+\\.injectable(\\.${platform})?\\.tsx?$/`,
CONTEXT_MATCHER_FOR_NON_FEATURES: `/\\.injectable\\.tsx?$/`,
CONTEXT_MATCHER_FOR_FEATURES: `/\\/(renderer|common)\\/.+\\.injectable\\.tsx?$/`,
}),
new ForkTsCheckerPlugin(),

2
packages/technical-features/application/agnostic/index.ts
View File

@ -7,3 +7,5 @@ export { startApplicationInjectionToken } from "./src/start-application/start-ap
export { applicationInformationToken } from "./src/application-information-token.no-coverage";
export type { ApplicationInformation } from "./src/application-information-token.no-coverage";
export { lensBuildEnvironmentInjectionToken } from "./src/environment-token";

22
packages/technical-features/application/agnostic/src/environment-token.test.ts Normal file
View File

@ -0,0 +1,22 @@
import { createContainer, DiContainer, getInjectable } from "@ogre-tools/injectable";
import { lensBuildEnvironmentInjectionToken } from "./environment-token";
describe("environment-token coverage tests", () => {
let di: DiContainer;
beforeEach(() => {
di = createContainer("irrelevant");
});
it("should be able to specify a build environment", () => {
di.register(
getInjectable({
id: "some-id",
instantiate: () => "some-value",
injectionToken: lensBuildEnvironmentInjectionToken,
}),
);
expect(di.inject(lensBuildEnvironmentInjectionToken)).toBe("some-value");
});
});

9
packages/technical-features/application/agnostic/src/environment-token.ts Normal file
View File

@ -0,0 +1,9 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectionToken } from "@ogre-tools/injectable";
export const lensBuildEnvironmentInjectionToken = getInjectionToken<string>({
id: "lens-build-environment-token",
});

4
packages/technical-features/application/agnostic/src/start-application/start-application.injectable.ts
View File

@ -13,9 +13,7 @@ const startApplicationInjectable = getInjectable({
instantiate: (di): StartApplication => {
const runManyAsync = runManyFor(di);
const beforeApplicationIsLoading = runManyAsync(
timeSlots.beforeApplicationIsLoadingInjectionToken,
);
const beforeApplicationIsLoading = runManyAsync(timeSlots.beforeApplicationIsLoadingInjectionToken);
const onLoadOfApplication = runManyAsync(timeSlots.onLoadOfApplicationInjectionToken);
const afterApplicationIsLoaded = runManyAsync(timeSlots.afterApplicationIsLoadedInjectionToken);

7
packages/technical-features/application/electron-main/src/start-application/start-electron-application.injectable.ts
View File

@ -1,9 +1,4 @@
import {
DiContainer,
getInjectable,
instantiationDecoratorToken,
lifecycleEnum,
} from "@ogre-tools/injectable";
import { DiContainer, getInjectable, instantiationDecoratorToken, lifecycleEnum } from "@ogre-tools/injectable";
import { startApplicationInjectionToken } from "@k8slens/application";
import whenAppIsReadyInjectable from "./when-app-is-ready.injectable";
import { beforeAnythingInjectionToken, beforeElectronIsReadyInjectionToken } from "./time-slots";

5
packages/technical-features/application/electron-main/src/starting-of-electron-main-application.test.ts
View File

@ -1,10 +1,7 @@
import { createContainer, DiContainer, getInjectable } from "@ogre-tools/injectable";
import { registerFeature } from "@k8slens/feature-core";
import { applicationFeatureForElectronMain } from "./feature";
import {
beforeApplicationIsLoadingInjectionToken,
startApplicationInjectionToken,
} from "@k8slens/application";
import { beforeApplicationIsLoadingInjectionToken, startApplicationInjectionToken } from "@k8slens/application";
import asyncFn, { AsyncFnMock } from "@async-fn/jest";
import whenAppIsReadyInjectable from "./start-application/when-app-is-ready.injectable";
import * as timeSlots from "./start-application/time-slots";

10
packages/technical-features/application/legacy-extensions/src/bundled-extension.ts
View File

@ -1,13 +1,13 @@
import { getInjectionToken } from "@ogre-tools/injectable";
import type {
LensExtensionConstructor,
LensExtensionManifest,
BundledLensExtensionConstructor,
BundledLensExtensionManifest,
} from "./lens-extension";
export interface BundledExtension {
readonly manifest: LensExtensionManifest;
main: () => LensExtensionConstructor | null;
renderer: () => LensExtensionConstructor | null;
readonly manifest: BundledLensExtensionManifest;
main: () => Promise<BundledLensExtensionConstructor | null>;
renderer: () => Promise<BundledLensExtensionConstructor | null>;
}
export const bundledExtensionInjectionToken =

62
packages/technical-features/application/legacy-extensions/src/lens-extension.ts
View File

@ -1,26 +1,39 @@
export type LensExtensionId = string;
export type LensExtensionConstructor = new (
ext: InstalledExtension
) => LegacyLensExtension;
export type BundledLensExtensionConstructor = new (
ext: BundledInstalledExtension
) => LegacyLensExtension;
export interface InstalledExtension {
id: LensExtensionId;
readonly manifest: LensExtensionManifest;
export interface BaseInstalledExtension {
readonly id: LensExtensionId;
// Absolute path to the non-symlinked source folder,
// e.g. "/Users/user/.k8slens/extensions/helloworld"
readonly absolutePath: string;
/**
* Absolute to the symlinked package.json file
*/
// Absolute to the symlinked package.json file
readonly manifestPath: string;
readonly isBundled: boolean;
}
export interface BundledInstalledExtension extends BaseInstalledExtension {
readonly manifest: BundledLensExtensionManifest;
readonly isBundled: true;
readonly isCompatible: true;
readonly isEnabled: true;
}
export interface ExternalInstalledExtension extends BaseInstalledExtension {
readonly manifest: LensExtensionManifest;
readonly isBundled: false;
readonly isCompatible: boolean;
isEnabled: boolean;
}
export type InstalledExtension =
| BundledInstalledExtension
| ExternalInstalledExtension;
export interface LegacyLensExtension {
readonly id: LensExtensionId;
readonly manifest: LensExtensionManifest;
@ -38,22 +51,11 @@ export interface LegacyLensExtension {
activate(): Promise<void>;
}
export interface LensExtensionManifest {
export interface BundledLensExtensionManifest {
name: string;
version: string;
description?: string;
main?: string; // path to %ext/dist/main.js
renderer?: string; // path to %ext/dist/renderer.js
/**
* Supported Lens version engine by extension could be defined in `manifest.engines.lens`
* Only MAJOR.MINOR version is taken in consideration.
*/
engines: {
lens: string; // "semver"-package format
npm?: string;
node?: string;
};
publishConfig?: Partial<Record<string, string>>;
/**
* Specify extension name used for persisting data.
@ -61,3 +63,17 @@ export interface LensExtensionManifest {
*/
storeName?: string;
}
export interface LensExtensionManifest extends BundledLensExtensionManifest {
main?: string; // path to %ext/dist/main.js
renderer?: string; // path to %ext/dist/renderer.js
/**
* Supported Lens version engine by extension could be defined in `manifest.engines.lens`
* Only MAJOR.MINOR version is taken in consideration.
*/
engines: {
lens: string; // "semver"-package format
[x: string]: string | undefined;
};
}

12
packages/technical-features/feature-core/src/deregister-feature.ts
View File

@ -2,9 +2,7 @@ import type { DiContainer } from "@ogre-tools/injectable";
import type { Feature } from "./feature";
import { featureContextMapInjectable } from "./feature-context-map-injectable";
const getDependingFeaturesFor = (
featureContextMap: Map<Feature, { dependedBy: Map<Feature, number> }>,
) => {
const getDependingFeaturesFor = (featureContextMap: Map<Feature, { dependedBy: Map<Feature, number> }>) => {
const getDependingFeaturesForRecursion = (feature: Feature, atRoot = true): string[] => {
const context = featureContextMap.get(feature);
@ -36,11 +34,9 @@ const deregisterFeatureRecursed = (di: DiContainer, feature: Feature, dependedBy
const dependingFeatures = getDependingFeatures(feature);
if (!dependedBy && dependingFeatures.length) {
throw new Error(
`Tried to deregister Feature "${
feature.id
}", but it is the dependency of Features "${dependingFeatures.join(", ")}"`,
);
const names = dependingFeatures.join(", ");
throw new Error(`Tried to deregister Feature "${feature.id}", but it is the dependency of Features "${names}"`);
}
if (dependedBy) {

16
packages/technical-features/feature-core/src/feature-dependencies.test.ts
View File

@ -59,9 +59,7 @@ describe("feature-dependencies", () => {
expect(() => {
deregisterFeature(di, someDependencyFeature);
}).toThrow(
'Tried to deregister feature "some-dependency-feature", but it was not registered.',
);
}).toThrow('Tried to deregister feature "some-dependency-feature", but it was not registered.');
});
it("given the parent Feature is deregistered, when injecting an injectable from the dependency Feature, throws", () => {
@ -104,9 +102,7 @@ describe("feature-dependencies", () => {
it("when the first Feature is deregistered, throws", () => {
expect(() => {
deregisterFeature(di, someFeature1);
}).toThrow(
'Tried to deregister Feature "some-feature-1", but it is the dependency of Features "some-feature-2"',
);
}).toThrow('Tried to deregister Feature "some-feature-1", but it is the dependency of Features "some-feature-2"');
});
it("given the second Feature is deregistered, when injecting an injectable from the first Feature, still does so", () => {
@ -180,9 +176,7 @@ describe("feature-dependencies", () => {
expect(() => {
di.inject(someInjectableInDependencyFeature);
}).toThrow(
'Tried to inject non-registered injectable "irrelevant" -> "some-injectable-in-dependency-feature".',
);
}).toThrow('Tried to inject non-registered injectable "irrelevant" -> "some-injectable-in-dependency-feature".');
});
});
@ -256,9 +250,7 @@ describe("feature-dependencies", () => {
expect(() => {
di.inject(someInjectableInDependencyFeature);
}).toThrow(
'Tried to inject non-registered injectable "irrelevant" -> "some-injectable-in-dependency-feature".',
);
}).toThrow('Tried to inject non-registered injectable "irrelevant" -> "some-injectable-in-dependency-feature".');
});
});
});

10
packages/technical-features/feature-core/src/register-feature.ts
View File

@ -1,10 +1,7 @@
import type { DiContainer } from "@ogre-tools/injectable";
import { getInjectable } from "@ogre-tools/injectable";
import type { Feature } from "./feature";
import {
featureContextMapInjectable,
featureContextMapInjectionToken,
} from "./feature-context-map-injectable";
import { featureContextMapInjectable, featureContextMapInjectionToken } from "./feature-context-map-injectable";
const createFeatureContext = (feature: Feature, di: DiContainer) => {
const featureContextInjectable = getInjectable({
@ -58,10 +55,9 @@ const registerFeatureRecursed = (di: DiContainer, feature: Feature, dependedBy?:
if (dependedBy) {
const oldNumberOfDependents = featureContext.dependedBy.get(dependedBy) || 0;
const newNumberOfDependents = oldNumberOfDependents + 1;
const newNumberOfDependants = oldNumberOfDependents + 1;
featureContext.dependedBy.set(dependedBy, newNumberOfDependants);
featureContext.dependedBy.set(dependedBy, newNumberOfDependents);
}
if (!existingFeatureContext) {

10
packages/technical-features/messaging/agnostic/src/features/actual/index.ts
View File

@ -21,15 +21,9 @@ export {
getMessageChannelListenerInjectable,
} from "./message/message-channel-listener-injection-token";
export type {
RequestChannel,
RequestChannelHandler,
} from "./request/request-channel-listener-injection-token";
export type { RequestChannel, RequestChannelHandler } from "./request/request-channel-listener-injection-token";
export type {
RequestFromChannel,
ChannelRequester,
} from "./request/request-from-channel-injection-token";
export type { RequestFromChannel, ChannelRequester } from "./request/request-from-channel-injection-token";
export type { EnlistMessageChannelListener } from "./message/enlist-message-channel-listener-injection-token";
export { enlistMessageChannelListenerInjectionToken } from "./message/enlist-message-channel-listener-injection-token";

12
packages/technical-features/messaging/agnostic/src/features/actual/listening-of-channels/listening-of-channels.injectable.ts
View File

@ -21,9 +21,7 @@ export const listeningOfChannelsInjectionToken = getInjectionToken<ListeningOfCh
id: "listening-of-channels-injection-token",
});
const listening = <
T extends { id: string; channel: MessageChannel<any> | RequestChannel<any, any> },
>(
const listening = <T extends { id: string; channel: MessageChannel<any> | RequestChannel<any, any> }>(
channelListeners: IComputedValue<T[]>,
enlistChannelListener: (listener: T) => () => void,
getId: (listener: T) => string,
@ -33,9 +31,7 @@ const listening = <
const reactionDisposer = reaction(
() => channelListeners.get(),
(newValues, oldValues = []) => {
const addedListeners = newValues.filter(
(newValue) => !oldValues.some((oldValue) => oldValue.id === newValue.id),
);
const addedListeners = newValues.filter((newValue) => !oldValues.some((oldValue) => oldValue.id === newValue.id));
const removedListeners = oldValues.filter(
(oldValue) => !newValues.some((newValue) => newValue.id === oldValue.id),
@ -45,9 +41,7 @@ const listening = <
const id = getId(listener);
if (listenerDisposers.has(id)) {
throw new Error(
`Tried to add listener for channel "${listener.channel.id}" but listener already exists.`,
);
throw new Error(`Tried to add listener for channel "${listener.channel.id}" but listener already exists.`);
}
const disposer = enlistChannelListener(listener);

16
packages/technical-features/messaging/agnostic/src/features/actual/message/enlist-message-channel-listener-injection-token.ts
View File

@ -1,16 +1,10 @@
import type { Disposer } from "@k8slens/utilities";
import { getInjectionToken } from "@ogre-tools/injectable";
import type {
MessageChannel,
MessageChannelListener,
} from "./message-channel-listener-injection-token";
import type { MessageChannel, MessageChannelListener } from "./message-channel-listener-injection-token";
export type EnlistMessageChannelListener = <T>(
listener: MessageChannelListener<MessageChannel<T>>,
) => Disposer;
export type EnlistMessageChannelListener = <T>(listener: MessageChannelListener<MessageChannel<T>>) => Disposer;
export const enlistMessageChannelListenerInjectionToken =
getInjectionToken<EnlistMessageChannelListener>({
id: "listening-to-a-message-channel",
});
export const enlistMessageChannelListenerInjectionToken = getInjectionToken<EnlistMessageChannelListener>({
id: "listening-to-a-message-channel",
});

9
packages/technical-features/messaging/agnostic/src/features/actual/message/message-channel-listener-injection-token.ts
View File

@ -18,9 +18,7 @@ export interface MessageChannelListener<Channel> {
handler: MessageChannelHandler<Channel>;
}
export const messageChannelListenerInjectionToken = getInjectionToken<
MessageChannelListener<MessageChannel<unknown>>
>({
export const messageChannelListenerInjectionToken = getInjectionToken<MessageChannelListener<MessageChannel<unknown>>>({
id: "message-channel-listener",
});
@ -31,10 +29,7 @@ export interface GetMessageChannelListenerInfo<Channel extends MessageChannel<Me
causesSideEffects?: boolean;
}
export const getMessageChannelListenerInjectable = <
Channel extends MessageChannel<Message>,
Message,
>(
export const getMessageChannelListenerInjectable = <Channel extends MessageChannel<Message>, Message>(
info: GetMessageChannelListenerInfo<Channel, Message>,
) =>
getInjectable({

12
packages/technical-features/messaging/agnostic/src/features/actual/request/enlist-request-channel-listener-injection-token.ts
View File

@ -1,16 +1,12 @@
import type { Disposer } from "@k8slens/utilities/index";
import { getInjectionToken } from "@ogre-tools/injectable";
import type {
RequestChannel,
RequestChannelListener,
} from "./request-channel-listener-injection-token";
import type { RequestChannel, RequestChannelListener } from "./request-channel-listener-injection-token";
export type EnlistRequestChannelListener = <Request, Response>(
listener: RequestChannelListener<RequestChannel<Request, Response>>,
) => Disposer;
export const enlistRequestChannelListenerInjectionToken =
getInjectionToken<EnlistRequestChannelListener>({
id: "listening-to-a-request-channel",
});
export const enlistRequestChannelListenerInjectionToken = getInjectionToken<EnlistRequestChannelListener>({
id: "listening-to-a-request-channel",
});

4
packages/technical-features/messaging/agnostic/src/features/actual/request/get-request-channel.ts
View File

@ -1,7 +1,5 @@
import type { RequestChannel } from "./request-channel-listener-injection-token";
export const getRequestChannel = <Request, Response>(
id: string,
): RequestChannel<Request, Response> => ({
export const getRequestChannel = <Request, Response>(id: string): RequestChannel<Request, Response> => ({
id,
});

Some files were not shown because too many files have changed in this diff Show More