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 add-entity-settings-visibility

Browse Source
This commit is contained in:
Juho Heikka 2023-06-01 17:08:55 +03:00 committed by GitHub
commit 9911449ce9
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
212 changed files with 1592 additions and 1363 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
open-lens/build/notarize.js
View File

@ -2,7 +2,7 @@
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
const { notarize } = require("electron-notarize");
const { notarize } = require("@electron/notarize");
exports.default = async function notarizing(context) {
const { electronPlatformName, appOutDir } = context;
@ -22,6 +22,8 @@ exports.default = async function notarizing(context) {
appPath: `${appOutDir}/${appName}.app`,
appleId: process.env.APPLEID,
appleIdPassword: process.env.APPLEIDPASS,
ascProvider:process.env.ASCPROVIDER,
ascProvider: process.env.ASCPROVIDER,
teamId: process.env.APPLETEAMID,
tool: process.env.NOTARIZE_TOOL || "legacy",
});
};

5
open-lens/package.json
View File

@ -193,7 +193,7 @@
"@k8slens/json-api": "^1.0.0-alpha.3",
"@k8slens/keyboard-shortcuts": "^1.0.0",
"@k8slens/kube-api": "^1.0.0-alpha.1",
"@k8slens/kube-api-specifics": "^1.0.0-alpha.1",
"@k8slens/kube-api-specifics": "^1.0.0",
"@k8slens/kube-object": "^1.0.0",
"@k8slens/kubectl-versions": "^1.0.0",
"@k8slens/legacy-extension-example": "^1.0.0",
@ -206,6 +206,7 @@
"@k8slens/messaging-for-renderer": "^1.0.0",
"@k8slens/metrics": "^6.5.0",
"@k8slens/node-fetch": "^6.5.0",
"@k8slens/random": "^1.0.0",
"@k8slens/react-application": "^1.0.0",
"@k8slens/resizing-anchor": "^1.0.0",
"@k8slens/resource-templates": "^1.0.0",
@ -297,6 +298,7 @@
"xterm-link-provider": "^1.3.1"
},
"devDependencies": {
"@electron/notarize": "^1.2.3",
"@electron/rebuild": "^3.2.10",
"@k8slens/generate-tray-icons": "^6.5.0",
"@k8slens/test-utils": "^1.0.0",
@ -330,7 +332,6 @@
"css-loader": "^6.7.2",
"electron": "^22.3.10",
"electron-builder": "^23.6.0",
"electron-notarize": "^0.3.0",
"esbuild-loader": "^2.20.0",
"fork-ts-checker-webpack-plugin": "^7.3.0",
"html-webpack-plugin": "^5.5.1",

4
open-lens/src/main/index.ts
View File

@ -12,6 +12,8 @@ import { applicationFeature, startApplicationInjectionToken } from '@k8slens/app
import { applicationFeatureForElectronMain } from '@k8slens/application-for-electron-main'
import { messagingFeatureForMain } from "@k8slens/messaging-for-main";
import { loggerFeature } from "@k8slens/logger";
import { randomFeature } from "@k8slens/random";
import { kubeApiSpecificsFeature } from "@k8slens/kube-api-specifics";
const environment = "main";
@ -33,6 +35,8 @@ runInAction(() => {
applicationFeature,
applicationFeatureForElectronMain,
messagingFeatureForMain,
randomFeature,
kubeApiSpecificsFeature,
);
try {

4
open-lens/src/renderer/index.ts
View File

@ -29,6 +29,8 @@ import { routingFeature } from "@k8slens/routing";
import { loggerFeature } from "@k8slens/logger";
import { animateFeature } from "@k8slens/animate";
import { clusterSidebarFeature } from "@k8slens/cluster-sidebar";
import { randomFeature } from "@k8slens/random";
import { kubeApiSpecificsFeature } from "@k8slens/kube-api-specifics";
const environment = "renderer";
@ -56,6 +58,8 @@ runInAction(() => {
metricsFeature,
animateFeature,
clusterSidebarFeature,
randomFeature,
kubeApiSpecificsFeature,
);
autoRegister({

88
package-lock.json generated
View File

@ -2188,6 +2188,19 @@
"node": ">= 4.0.0"
}
},
"node_modules/@electron/notarize": {
"version": "1.2.3",
"resolved": "https://registry.npmjs.org/@electron/notarize/-/notarize-1.2.3.tgz",
"integrity": "sha512-9oRzT56rKh5bspk3KpAVF8lPKHYQrBnRwcgiOeR0hdilVEQmszDaAu0IPCPrwwzJN0ugNs0rRboTreHMt/6mBQ==",
"dev": true,
"dependencies": {
"debug": "^4.1.1",
"fs-extra": "^9.0.1"
},
"engines": {
"node": ">= 10.0.0"
}
},
"node_modules/@electron/rebuild": {
"version": "3.2.13",
"resolved": "https://registry.npmjs.org/@electron/rebuild/-/rebuild-3.2.13.tgz",
@ -3818,6 +3831,10 @@
"resolved": "packages/node-fetch",
"link": true
},
"node_modules/@k8slens/random": {
"resolved": "packages/random-id",
"link": true
},
"node_modules/@k8slens/react-application": {
"resolved": "packages/technical-features/react-application",
"link": true
@ -12749,49 +12766,6 @@
"url": "https://github.com/sponsors/isaacs"
}
},
"node_modules/electron-notarize": {
"version": "0.3.0",
"resolved": "https://registry.npmjs.org/electron-notarize/-/electron-notarize-0.3.0.tgz",
"integrity": "sha512-tuDw8H0gcDOalNLv6RM2CwGvUXU60MPGZRDEmd0ppX+yP5XqL8Ec2DuXyz9J7WQSA3aRCfzIgH8C5CAivDYWMw==",
"deprecated": "Please use @electron/notarize moving forward. There is no API change, just a package name change",
"dev": true,
"dependencies": {
"debug": "^4.1.1",
"fs-extra": "^8.1.0"
}
},
"node_modules/electron-notarize/node_modules/fs-extra": {
"version": "8.1.0",
"resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz",
"integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==",
"dev": true,
"dependencies": {
"graceful-fs": "^4.2.0",
"jsonfile": "^4.0.0",
"universalify": "^0.1.0"
},
"engines": {
"node": ">=6 <7 || >=8"
}
},
"node_modules/electron-notarize/node_modules/jsonfile": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz",
"integrity": "sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==",
"dev": true,
"optionalDependencies": {
"graceful-fs": "^4.1.6"
}
},
"node_modules/electron-notarize/node_modules/universalify": {
"version": "0.1.2",
"resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz",
"integrity": "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==",
"dev": true,
"engines": {
"node": ">= 4.0.0"
}
},
"node_modules/electron-osx-sign": {
"version": "0.6.0",
"resolved": "https://registry.npmjs.org/electron-osx-sign/-/electron-osx-sign-0.6.0.tgz",
@ -34006,7 +33980,7 @@
"@k8slens/json-api": "^1.0.0-alpha.3",
"@k8slens/keyboard-shortcuts": "^1.0.0",
"@k8slens/kube-api": "^1.0.0-alpha.1",
"@k8slens/kube-api-specifics": "^1.0.0-alpha.1",
"@k8slens/kube-api-specifics": "^1.0.0",
"@k8slens/kube-object": "^1.0.0",
"@k8slens/kubectl-versions": "^1.0.0",
"@k8slens/legacy-extension-example": "^1.0.0",
@ -34019,6 +33993,7 @@
"@k8slens/messaging-for-renderer": "^1.0.0",
"@k8slens/metrics": "^6.5.0",
"@k8slens/node-fetch": "^6.5.0",
"@k8slens/random": "^1.0.0",
"@k8slens/react-application": "^1.0.0",
"@k8slens/resizing-anchor": "^1.0.0",
"@k8slens/resource-templates": "^1.0.0",
@ -34110,6 +34085,7 @@
"xterm-link-provider": "^1.3.1"
},
"devDependencies": {
"@electron/notarize": "^1.2.3",
"@electron/rebuild": "^3.2.10",
"@k8slens/generate-tray-icons": "^6.5.0",
"@k8slens/test-utils": "^1.0.0",
@ -34143,7 +34119,6 @@
"css-loader": "^6.7.2",
"electron": "^22.3.10",
"electron-builder": "^23.6.0",
"electron-notarize": "^0.3.0",
"esbuild-loader": "^2.20.0",
"fork-ts-checker-webpack-plugin": "^7.3.0",
"html-webpack-plugin": "^5.5.1",
@ -34360,6 +34335,7 @@
"@k8slens/messaging-for-renderer": "^1.0.0-alpha.1",
"@k8slens/metrics": "^6.5.0-alpha.7",
"@k8slens/node-fetch": "^6.5.0-alpha.3",
"@k8slens/random": "^1.0.0",
"@k8slens/react-application": "^1.0.0-alpha.5",
"@k8slens/resizing-anchor": "^1.0.0-alpha.5",
"@k8slens/resource-templates": "^1.0.0-alpha.1",
@ -35272,6 +35248,21 @@
"url": "https://opencollective.com/node-fetch"
}
},
"packages/random-id": {
"name": "@k8slens/random",
"version": "1.0.0",
"license": "MIT",
"devDependencies": {
"@k8slens/eslint-config": "^6.5.0",
"@k8slens/webpack": "^6.5.0"
},
"peerDependencies": {
"@k8slens/feature-core": "^6.5.0-alpha.0",
"@ogre-tools/injectable": "^17.1.0",
"@ogre-tools/injectable-extension-for-auto-registration": "^17.1.0",
"uuid": "^8.3.2"
}
},
"packages/release-tool": {
"name": "@k8slens/release-tool",
"version": "6.5.0",
@ -35794,7 +35785,7 @@
},
"packages/utility-features/kube-api-specifics": {
"name": "@k8slens/kube-api-specifics",
"version": "1.0.0-alpha.1",
"version": "1.0.0",
"license": "MIT",
"devDependencies": {
"@k8slens/eslint-config": "^6.5.0-alpha.2",
@ -35802,8 +35793,11 @@
"@k8slens/typescript": "^6.5.0-alpha.2"
},
"peerDependencies": {
"@k8slens/feature-core": "^6.5.0-alpha.8",
"@k8slens/kube-api": "^1.0.0-alpha.1",
"@ogre-tools/injectable": "^17.2.0"
"@k8slens/logger": "^1.0.0",
"@ogre-tools/injectable": "^17.2.0",
"@ogre-tools/injectable-extension-for-auto-registration": "^17.2.0"
}
},
"packages/utility-features/react-testing-library-discovery": {

1
packages/core/package.json
View File

@ -229,6 +229,7 @@
"@k8slens/metrics": "^6.5.0-alpha.7",
"@k8slens/node-fetch": "^6.5.0-alpha.3",
"@k8slens/react-application": "^1.0.0-alpha.5",
"@k8slens/random": "^1.0.0",
"@k8slens/resizing-anchor": "^1.0.0-alpha.5",
"@k8slens/resource-templates": "^1.0.0-alpha.1",
"@k8slens/routing": "^1.0.0-alpha.5",

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

@ -11,13 +11,12 @@ import { getDiForUnitTesting } from "../../../renderer/getDiForUnitTesting";
import storesAndApisCanBeCreatedInjectable from "../../../renderer/stores-apis-can-be-created.injectable";
import directoryForKubeConfigsInjectable from "../../app-paths/directory-for-kube-configs/directory-for-kube-configs.injectable";
import directoryForUserDataInjectable from "../../app-paths/directory-for-user-data/directory-for-user-data.injectable";
import { loggerInjectionToken } from "@k8slens/logger";
import { logErrorInjectionToken, loggerInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
import type { ApiManager } from "../api-manager";
import apiManagerInjectable from "../api-manager/manager.injectable";
import { KubeApi } from "@k8slens/kube-api";
import { KubeObject } from "@k8slens/kube-object";
import { KubeObjectStore } from "../kube-object.store";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
// eslint-disable-next-line no-restricted-imports
import { KubeApi as ExternalKubeApi } from "../../../extensions/common-api/k8s-api";
@ -25,6 +24,7 @@ import { Cluster } from "../../cluster/cluster";
import { runInAction } from "mobx";
import { customResourceDefinitionApiInjectionToken } from "../api-manager/crd-api-token";
import assert from "assert";
import { maybeKubeApiInjectable } from "@k8slens/kube-api-specifics";
class TestApi extends KubeApi<KubeObject> {
protected checkPreferredVersion() {
@ -61,7 +61,9 @@ describe("ApiManager", () => {
const apiBase = "api/v1/foo";
const fallbackApiBase = "/apis/extensions/v1beta1/foo";
const kubeApi = new TestApi({
logger: di.inject(loggerInjectionToken),
logError: di.inject(logErrorInjectionToken),
logInfo: di.inject(logInfoInjectionToken),
logWarn: di.inject(logWarningInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}, {
objectConstructor: KubeObject,
@ -136,7 +138,9 @@ describe("ApiManager", () => {
return Object.assign(
new KubeApi({
logger: di.inject(loggerInjectionToken),
logError: di.inject(logErrorInjectionToken),
logInfo: di.inject(logInfoInjectionToken),
logWarn: di.inject(logWarningInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}, { objectConstructor }),
{

9
packages/core/src/common/k8s-api/__tests__/kube-api-version-detection.test.ts
View File

@ -20,9 +20,8 @@ import hostedClusterInjectable from "../../../renderer/cluster-frame-context/hos
import directoryForKubeConfigsInjectable from "../../app-paths/directory-for-kube-configs/directory-for-kube-configs.injectable";
import apiManagerInjectable from "../api-manager/manager.injectable";
import type { DiContainer } from "@ogre-tools/injectable";
import ingressApiInjectable from "../endpoints/ingress.api.injectable";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
import { ingressApiInjectable, maybeKubeApiInjectable } from "@k8slens/kube-api-specifics";
import { logErrorInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
import { Cluster } from "../../cluster/cluster";
describe("KubeApi", () => {
@ -710,7 +709,9 @@ describe("KubeApi", () => {
beforeEach(async () => {
horizontalPodAutoscalerApi = new HorizontalPodAutoscalerApi({
logger: di.inject(loggerInjectionToken),
logError: di.inject(logErrorInjectionToken),
logInfo: di.inject(logInfoInjectionToken),
logWarn: di.inject(logWarningInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}, {
allowedUsableVersions: {

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

@ -22,7 +22,7 @@ import hostedClusterInjectable from "../../../renderer/cluster-frame-context/hos
import directoryForKubeConfigsInjectable from "../../app-paths/directory-for-kube-configs/directory-for-kube-configs.injectable";
import apiKubeInjectable from "../../../renderer/k8s/api-kube.injectable";
import type { DiContainer } from "@ogre-tools/injectable";
import podApiInjectable from "../endpoints/pod.api.injectable";
import { podApiInjectable } from "@k8slens/kube-api-specifics";
// NOTE: this is fine because we are testing something that only exported
// eslint-disable-next-line no-restricted-imports

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

@ -3,11 +3,10 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ApiManager } from "./api-manager";
import { computedInjectManyInjectable } from "@ogre-tools/injectable-extension-for-mobx";
import { kubeObjectStoreInjectionToken } from "./kube-object-store-token";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { kubeApiInjectionToken, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
import { computed } from "mobx";
import { customResourceDefinitionApiInjectionToken } from "./crd-api-token";
import createCustomResourceStoreInjectable from "./create-custom-resource-store.injectable";

10
packages/core/src/common/k8s-api/create-kube-api-for-cluster.injectable.ts
View File

@ -3,7 +3,7 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import { loggerInjectionToken } from "@k8slens/logger";
import { logErrorInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
import { apiKubePrefix } from "../vars";
import isDevelopmentInjectable from "../vars/is-development.injectable";
import apiBaseInjectable from "./api-base.injectable";
@ -37,7 +37,9 @@ const createKubeApiForClusterInjectable = getInjectable({
const apiBase = di.inject(apiBaseInjectable);
const isDevelopment = di.inject(isDevelopmentInjectable);
const createKubeJsonApi = di.inject(createKubeJsonApiInjectable);
const logger = di.inject(loggerInjectionToken);
const logError = di.inject(logErrorInjectionToken);
const logInfo = di.inject(logInfoInjectionToken);
const logWarn = di.inject(logWarningInjectionToken);
return (
cluster: CreateKubeApiForLocalClusterConfig,
@ -64,7 +66,9 @@ const createKubeApiForClusterInjectable = getInjectable({
return new KubeApi(
{
logger,
logError,
logInfo,
logWarn,
maybeKubeApi: undefined,
},
{

10
packages/core/src/common/k8s-api/create-kube-api-for-remote-cluster.injectable.ts
View File

@ -6,7 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
import type { AgentOptions } from "https";
import { Agent } from "https";
import type { RequestInit } from "@k8slens/node-fetch";
import { loggerInjectionToken } from "@k8slens/logger";
import { logErrorInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
import isDevelopmentInjectable from "../vars/is-development.injectable";
import createKubeJsonApiInjectable from "./create-kube-json-api.injectable";
import type { KubeApiOptions } from "@k8slens/kube-api";
@ -53,7 +53,9 @@ const createKubeApiForRemoteClusterInjectable = getInjectable({
instantiate: (di): CreateKubeApiForRemoteCluster => {
const isDevelopment = di.inject(isDevelopmentInjectable);
const createKubeJsonApi = di.inject(createKubeJsonApiInjectable);
const logger = di.inject(loggerInjectionToken);
const logError = di.inject(logErrorInjectionToken);
const logInfo = di.inject(logInfoInjectionToken);
const logWarn = di.inject(logWarningInjectionToken);
return (
config: CreateKubeApiForRemoteClusterConfig,
@ -110,7 +112,9 @@ const createKubeApiForRemoteClusterInjectable = getInjectable({
return new KubeApi(
{
logger,
logError,
logInfo,
logWarn,
maybeKubeApi: undefined,
},
{

8
packages/core/src/common/k8s-api/create-kube-api.injectable.ts
View File

@ -3,9 +3,9 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import { loggerInjectionToken } from "@k8slens/logger";
import { logErrorInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
import type { DerivedKubeApiOptions, KubeApiDependencies } from "@k8slens/kube-api";
import maybeKubeApiInjectable from "./maybe-kube-api.injectable";
import { maybeKubeApiInjectable } from "@k8slens/kube-api-specifics";
export interface CreateKubeApi {
<Api>(ctor: new (deps: KubeApiDependencies, opts: DerivedKubeApiOptions) => Api, opts?: DerivedKubeApiOptions): Api;
@ -15,7 +15,9 @@ const createKubeApiInjectable = getInjectable({
id: "create-kube-api",
instantiate: (di): CreateKubeApi => {
const deps: KubeApiDependencies = {
logger: di.inject(loggerInjectionToken),
logError: di.inject(logErrorInjectionToken),
logInfo: di.inject(logInfoInjectionToken),
logWarn: di.inject(logWarningInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
};

27
packages/core/src/common/k8s-api/endpoints/cluster-role-binding.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ClusterRoleBindingApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const clusterRoleBindingApiInjectable = getInjectable({
id: "cluster-role-binding-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterRoleBindingApi is only accessible in certain environments");
return new ClusterRoleBindingApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default clusterRoleBindingApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/cluster-role.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ClusterRoleApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const clusterRoleApiInjectable = getInjectable({
id: "cluster-role-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterRoleApi is only available in certain environments");
return new ClusterRoleApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default clusterRoleApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/component-status.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ComponentStatusApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
import { loggerInjectionToken } from "@k8slens/logger";
const componentStatusApiInjectable = getInjectable({
id: "component-status-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "componentStatusApi is only available in certain environments");
return new ComponentStatusApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default componentStatusApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/config-map.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ConfigMapApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const configMapApiInjectable = getInjectable({
id: "config-map-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "configMapApi is only available in certain environments");
return new ConfigMapApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default configMapApiInjectable;

29
packages/core/src/common/k8s-api/endpoints/cron-job.api.injectable.ts
View File

@ -1,29 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { CronJobApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const cronJobApiInjectable = getInjectable({
id: "cron-job-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "cronJobApi is only available in certain environments");
return new CronJobApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}, {
checkPreferredVersion: true,
});
},
injectionToken: kubeApiInjectionToken,
});
export default cronJobApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/custom-resource-definition.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { CustomResourceDefinitionApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
import { loggerInjectionToken } from "@k8slens/logger";
const customResourceDefinitionApiInjectable = getInjectable({
id: "custom-resource-definition-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "customResourceDefinitionApi is only available in certain environments");
return new CustomResourceDefinitionApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default customResourceDefinitionApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/daemon-set.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { DaemonSetApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const daemonSetApiInjectable = getInjectable({
id: "daemon-set-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "daemonSetApi is only available in certain environments");
return new DaemonSetApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default daemonSetApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/deployment.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { DeploymentApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const deploymentApiInjectable = getInjectable({
id: "deployment-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "deploymentApi is only available in certain environments");
return new DeploymentApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default deploymentApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/endpoint.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { EndpointsApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const endpointsApiInjectable = getInjectable({
id: "endpoints-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "endpointsApi is only available in certain environments");
return new EndpointsApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default endpointsApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/events.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { KubeEventApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const kubeEventApiInjectable = getInjectable({
id: "kube-event-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "kubeEventApi is only available in certain environments");
return new KubeEventApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default kubeEventApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/horizontal-pod-autoscaler.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { HorizontalPodAutoscalerApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const horizontalPodAutoscalerApiInjectable = getInjectable({
id: "horizontal-pod-autoscaler-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "horizontalPodAutoscalerApi is only available in certain environments");
return new HorizontalPodAutoscalerApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default horizontalPodAutoscalerApiInjectable;

21
packages/core/src/common/k8s-api/endpoints/ingress-class.api.injectable.ts
View File

@ -1,21 +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 { IngressClassApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const ingressClassApiInjectable = getInjectable({
id: "ingress-class-api",
instantiate: (di) => new IngressClassApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}),
injectionToken: kubeApiInjectionToken,
});
export default ingressClassApiInjectable;

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

@ -1,29 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { JobApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const jobApiInjectable = getInjectable({
id: "job-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "jobApi is only available in certain environments");
return new JobApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}, {
checkPreferredVersion: true,
});
},
injectionToken: kubeApiInjectionToken,
});
export default jobApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/limit-range.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { LimitRangeApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const limitRangeApiInjectable = getInjectable({
id: "limit-range-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "limitRangeApi is only available in certain environments");
return new LimitRangeApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default limitRangeApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/mutating-webhook-configuration-api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { MutatingWebhookConfigurationApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const mutatingWebhookConfigurationApiInjectable = getInjectable({
id: "mutating-webhook-configuration",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "mutatingWebhookApi is only available in certain environments");
return new MutatingWebhookConfigurationApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default mutatingWebhookConfigurationApiInjectable;

28
packages/core/src/common/k8s-api/endpoints/namespace.api.injectable.ts
View File

@ -1,28 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { NamespaceApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const namespaceApiInjectable = getInjectable({
id: "namespace-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "namespaceApi is only available in certain environments");
return new NamespaceApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default namespaceApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/network-policy.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { NetworkPolicyApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const networkPolicyApiInjectable = getInjectable({
id: "network-policy-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "networkPolicyApi is only available in certain environments");
return new NetworkPolicyApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default networkPolicyApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/persistent-volume-claim.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PersistentVolumeClaimApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const persistentVolumeClaimApiInjectable = getInjectable({
id: "persistent-volume-claim-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "persistentVolumeClaimApi is only available in certain environments");
return new PersistentVolumeClaimApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default persistentVolumeClaimApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/persistent-volume.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PersistentVolumeApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const persistentVolumeApiInjectable = getInjectable({
id: "persistent-volume-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "persistentVolumeApi is only available in certain environments");
return new PersistentVolumeApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default persistentVolumeApiInjectable;

35
packages/core/src/common/k8s-api/endpoints/pod-disruption-budget.api.injectable.ts
View File

@ -1,35 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PodDisruptionBudgetApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const podDisruptionBudgetApiInjectable = getInjectable({
id: "pod-disruption-budget-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podDisruptionBudgetApi is only available in certain environments");
return new PodDisruptionBudgetApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}, {
checkPreferredVersion: true,
allowedUsableVersions: {
policy: [
"v1",
"v1beta1",
],
},
});
},
injectionToken: kubeApiInjectionToken,
});
export default podDisruptionBudgetApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/pod-metrics.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PodMetricsApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const podMetricsApiInjectable = getInjectable({
id: "pod-metrics-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podMetricsApi is only available in certain environments");
return new PodMetricsApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default podMetricsApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/pod-security-policy.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PodSecurityPolicyApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const podSecurityPolicyApiInjectable = getInjectable({
id: "pod-security-policy-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podSecurityPolicyApi is only available in certain environments");
return new PodSecurityPolicyApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default podSecurityPolicyApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/priority-class.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PriorityClassApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const priorityClassApiInjectable = getInjectable({
id: "priority-class-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "PriorityClassApi is only available in certain environments");
return new PriorityClassApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default priorityClassApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/replica-set.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ReplicaSetApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const replicaSetApiInjectable = getInjectable({
id: "replica-set-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "replicaSetApi is only available in certain environments");
return new ReplicaSetApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default replicaSetApiInjectable;

23
packages/core/src/common/k8s-api/endpoints/replication-controller.api.injectable.ts
View File

@ -1,23 +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 { ReplicationControllerApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const replicationControllerApiInjectable = getInjectable({
id: "replication-controller-api",
instantiate: (di) => {
return new ReplicationControllerApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default replicationControllerApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/resource-quota.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ResourceQuotaApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const resourceQuotaApiInjectable = getInjectable({
id: "resource-quota-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "resourceQuotaApi is only available in certain environments");
return new ResourceQuotaApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default resourceQuotaApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/role-binding.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { RoleBindingApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const roleBindingApiInjectable = getInjectable({
id: "role-binding-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "roleBindingApi is only available in certain environments");
return new RoleBindingApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default roleBindingApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/runtime-class.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { RuntimeClassApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const runtimeClassApiInjectable = getInjectable({
id: "runtime-class-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "RuntimeClassApi is only available in certain environments");
return new RuntimeClassApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default runtimeClassApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/self-subject-rules-reviews.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { SelfSubjectRulesReviewApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const selfSubjectRulesReviewApiInjectable = getInjectable({
id: "self-subject-rules-review-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "selfSubjectRulesReviewApi is only available in certain environments");
return new SelfSubjectRulesReviewApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default selfSubjectRulesReviewApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/service-account.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ServiceAccountApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const serviceAccountApiInjectable = getInjectable({
id: "service-account-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "serviceAccountApi is only available in certain environments");
return new ServiceAccountApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default serviceAccountApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/stateful-set.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { StatefulSetApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const statefulSetApiInjectable = getInjectable({
id: "stateful-set-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "statefulSetApi is only available in certain environments");
return new StatefulSetApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default statefulSetApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/storage-class.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { StorageClassApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const storageClassApiInjectable = getInjectable({
id: "storage-class-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "storageClassApi is only available in certain environments");
return new StorageClassApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default storageClassApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/validating-webhook-configuration-api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ValidatingWebhookConfigurationApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const validatingWebhookConfigurationApiInjectable = getInjectable({
id: "validating-webhook-configuration",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "validatingWebhookApi is only available in certain environments");
return new ValidatingWebhookConfigurationApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default validatingWebhookConfigurationApiInjectable;

27
packages/core/src/common/k8s-api/endpoints/vertical-pod-autoscaler.api.injectable.ts
View File

@ -1,27 +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 assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { VerticalPodAutoscalerApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const verticalPodAutoscalerApiInjectable = getInjectable({
id: "vertical-pod-autoscaler-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "verticalPodAutoscalerApi is only available in certain environments");
return new VerticalPodAutoscalerApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default verticalPodAutoscalerApiInjectable;

2
packages/core/src/common/k8s-api/selected-filter-namespaces.injectable.ts
View File

@ -2,10 +2,10 @@
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
import { getInjectable } from "@ogre-tools/injectable";
import { computed } from "mobx";
import clusterFrameContextForNamespacedResourcesInjectable from "../../renderer/cluster-frame-context/for-namespaced-resources.injectable";
import { storesAndApisCanBeCreatedInjectionToken } from "./stores-apis-can-be-created.token";
const selectedFilterNamespacesInjectable = getInjectable({
id: "selected-filter-namespaces",

4
packages/core/src/common/utils/get-random-id.global-override-for-injectable.ts
View File

@ -4,6 +4,6 @@
*/
import { getGlobalOverride } from "@k8slens/test-utils";
import getRandomIdInjectable from "./get-random-id.injectable";
import { getRandomIdInjectionToken } from "@k8slens/random";
export default getGlobalOverride(getRandomIdInjectable, () => () => "some-irrelevant-random-id");
export default getGlobalOverride(getRandomIdInjectionToken, () => () => "some-irrelevant-random-id");

14
packages/core/src/common/utils/get-random-id.injectable.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 { v4 as getRandomId } from "uuid";
const getRandomIdInjectable = getInjectable({
id: "get-random-id",
instantiate: () => () => getRandomId(),
causesSideEffects: true,
});
export default getRandomIdInjectable;

9
packages/core/src/extensions/common-api/k8s-api.ts
View File

@ -20,10 +20,9 @@ import type { KubeJsonApiDataFor, KubeObject } from "@k8slens/kube-object";
import type { DerivedKubeApiOptions, KubeApiDependencies, KubeApiOptions, KubeJsonApi as InternalKubeJsonApi } from "@k8slens/kube-api";
import clusterFrameContextForNamespacedResourcesInjectable from "../../renderer/cluster-frame-context/for-namespaced-resources.injectable";
import type { ClusterContext } from "../../renderer/cluster-frame-context/cluster-frame-context";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../../common/k8s-api/maybe-kube-api.injectable";
import { logErrorInjectionToken, loggerInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
import { maybeKubeApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
import { DeploymentApi as InternalDeploymentApi, IngressApi as InternalIngressApi, NodeApi, PersistentVolumeClaimApi, PodApi, KubeApi as InternalKubeApi } from "@k8slens/kube-api";
import { storesAndApisCanBeCreatedInjectionToken } from "../../common/k8s-api/stores-apis-can-be-created.token";
import type { JsonApiConfig } from "@k8slens/json-api";
import createKubeJsonApiInjectable from "../../common/k8s-api/create-kube-json-api.injectable";
import type { RequestInit } from "@k8slens/node-fetch";
@ -40,7 +39,9 @@ const getKubeApiDeps = (): KubeApiDependencies => {
const di = getLegacyGlobalDiForExtensionApi();
return {
logger: di.inject(loggerInjectionToken),
logError: di.inject(logErrorInjectionToken),
logInfo: di.inject(logInfoInjectionToken),
logWarn: di.inject(logWarningInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
};
};

94
packages/core/src/extensions/renderer-api/k8s-api.ts
View File

@ -5,37 +5,7 @@
import type { KubeResource } from "../../common/rbac";
import { apiResourceRecord } from "../../common/rbac";
import { getLegacyGlobalDiForExtensionApi, asLegacyGlobalForExtensionApi, asLegacyGlobalFunctionForExtensionApi } from "@k8slens/legacy-global-di";
import clusterRoleBindingApiInjectable from "../../common/k8s-api/endpoints/cluster-role-binding.api.injectable";
import clusterRoleApiInjectable from "../../common/k8s-api/endpoints/cluster-role.api.injectable";
import serviceAccountApiInjectable from "../../common/k8s-api/endpoints/service-account.api.injectable";
import roleApiInjectable from "../../common/k8s-api/endpoints/role.api.injectable";
import podApiInjectable from "../../common/k8s-api/endpoints/pod.api.injectable";
import daemonSetApiInjectable from "../../common/k8s-api/endpoints/daemon-set.api.injectable";
import replicaSetApiInjectable from "../../common/k8s-api/endpoints/replica-set.api.injectable";
import statefulSetApiInjectable from "../../common/k8s-api/endpoints/stateful-set.api.injectable";
import deploymentApiInjectable from "../../common/k8s-api/endpoints/deployment.api.injectable";
import jobApiInjectable from "../../common/k8s-api/endpoints/job.api.injectable";
import cronJobApiInjectable from "../../common/k8s-api/endpoints/cron-job.api.injectable";
import nodeApiInjectable from "../../common/k8s-api/endpoints/node.api.injectable";
import configMapApiInjectable from "../../common/k8s-api/endpoints/config-map.api.injectable";
import secretApiInjectable from "../../common/k8s-api/endpoints/secret.api.injectable";
import resourceQuotaApiInjectable from "../../common/k8s-api/endpoints/resource-quota.api.injectable";
import limitRangeApiInjectable from "../../common/k8s-api/endpoints/limit-range.api.injectable";
import horizontalPodAutoscalerApiInjectable from "../../common/k8s-api/endpoints/horizontal-pod-autoscaler.api.injectable";
import verticalPodAutoscalerApiInjectable from "../../common/k8s-api/endpoints/vertical-pod-autoscaler.api.injectable";
import podDisruptionBudgetApiInjectable from "../../common/k8s-api/endpoints/pod-disruption-budget.api.injectable";
import priorityClassStoreApiInjectable from "../../common/k8s-api/endpoints/priority-class.api.injectable";
import serviceApiInjectable from "../../common/k8s-api/endpoints/service.api.injectable";
import endpointsApiInjectable from "../../common/k8s-api/endpoints/endpoint.api.injectable";
import ingressApiInjectable from "../../common/k8s-api/endpoints/ingress.api.injectable";
import networkPolicyApiInjectable from "../../common/k8s-api/endpoints/network-policy.api.injectable";
import persistentVolumeApiInjectable from "../../common/k8s-api/endpoints/persistent-volume.api.injectable";
import persistentVolumeClaimApiInjectable from "../../common/k8s-api/endpoints/persistent-volume-claim.api.injectable";
import storageClassApiInjectable from "../../common/k8s-api/endpoints/storage-class.api.injectable";
import namespaceApiInjectable from "../../common/k8s-api/endpoints/namespace.api.injectable";
import kubeEventApiInjectable from "../../common/k8s-api/endpoints/events.api.injectable";
import roleBindingApiInjectable from "../../common/k8s-api/endpoints/role-binding.api.injectable";
import customResourceDefinitionApiInjectable from "../../common/k8s-api/endpoints/custom-resource-definition.api.injectable";
import * as kubeApiSpecifics from "@k8slens/kube-api-specifics";
import { shouldShowResourceInjectionToken } from "../../features/cluster/showing-kube-resources/common/allowed-resources-injection-token";
import requestMetricsInjectable from "../../common/k8s-api/endpoints/metrics.api/request-metrics.injectable";
@ -59,37 +29,37 @@ export function isAllowedResource(resources: KubeResource | KubeResource[]) {
});
}
export const serviceAccountsApi = asLegacyGlobalForExtensionApi(serviceAccountApiInjectable);
export const clusterRoleApi = asLegacyGlobalForExtensionApi(clusterRoleApiInjectable);
export const clusterRoleBindingApi = asLegacyGlobalForExtensionApi(clusterRoleBindingApiInjectable);
export const roleApi = asLegacyGlobalForExtensionApi(roleApiInjectable);
export const podsApi = asLegacyGlobalForExtensionApi(podApiInjectable);
export const daemonSetApi = asLegacyGlobalForExtensionApi(daemonSetApiInjectable);
export const replicaSetApi = asLegacyGlobalForExtensionApi(replicaSetApiInjectable);
export const statefulSetApi = asLegacyGlobalForExtensionApi(statefulSetApiInjectable);
export const deploymentApi = asLegacyGlobalForExtensionApi(deploymentApiInjectable);
export const jobApi = asLegacyGlobalForExtensionApi(jobApiInjectable);
export const cronJobApi = asLegacyGlobalForExtensionApi(cronJobApiInjectable);
export const nodesApi = asLegacyGlobalForExtensionApi(nodeApiInjectable);
export const secretsApi = asLegacyGlobalForExtensionApi(secretApiInjectable);
export const configMapApi = asLegacyGlobalForExtensionApi(configMapApiInjectable);
export const resourceQuotaApi = asLegacyGlobalForExtensionApi(resourceQuotaApiInjectable);
export const limitRangeApi = asLegacyGlobalForExtensionApi(limitRangeApiInjectable);
export const serviceApi = asLegacyGlobalForExtensionApi(serviceApiInjectable);
export const hpaApi = asLegacyGlobalForExtensionApi(horizontalPodAutoscalerApiInjectable);
export const vpaApi = asLegacyGlobalForExtensionApi(verticalPodAutoscalerApiInjectable);
export const pdbApi = asLegacyGlobalForExtensionApi(podDisruptionBudgetApiInjectable);
export const pcApi = asLegacyGlobalForExtensionApi(priorityClassStoreApiInjectable);
export const endpointApi = asLegacyGlobalForExtensionApi(endpointsApiInjectable);
export const ingressApi = asLegacyGlobalForExtensionApi(ingressApiInjectable);
export const networkPolicyApi = asLegacyGlobalForExtensionApi(networkPolicyApiInjectable);
export const persistentVolumeApi = asLegacyGlobalForExtensionApi(persistentVolumeApiInjectable);
export const pvcApi = asLegacyGlobalForExtensionApi(persistentVolumeClaimApiInjectable);
export const storageClassApi = asLegacyGlobalForExtensionApi(storageClassApiInjectable);
export const namespacesApi = asLegacyGlobalForExtensionApi(namespaceApiInjectable);
export const eventApi = asLegacyGlobalForExtensionApi(kubeEventApiInjectable);
export const roleBindingApi = asLegacyGlobalForExtensionApi(roleBindingApiInjectable);
export const crdApi = asLegacyGlobalForExtensionApi(customResourceDefinitionApiInjectable);
export const serviceAccountsApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.serviceAccountApiInjectable);
export const clusterRoleApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.clusterRoleApiInjectable);
export const clusterRoleBindingApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.clusterRoleBindingApiInjectable);
export const roleApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.roleApiInjectable);
export const podsApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.podApiInjectable);
export const daemonSetApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.daemonSetApiInjectable);
export const replicaSetApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.replicaSetApiInjectable);
export const statefulSetApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.statefulSetApiInjectable);
export const deploymentApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.deploymentApiInjectable);
export const jobApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.jobApiInjectable);
export const cronJobApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.cronJobApiInjectable);
export const nodesApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.nodeApiInjectable);
export const secretsApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.secretApiInjectable);
export const configMapApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.configMapApiInjectable);
export const resourceQuotaApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.resourceQuotaApiInjectable);
export const limitRangeApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.limitRangeApiInjectable);
export const serviceApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.serviceApiInjectable);
export const hpaApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.horizontalPodAutoscalerApiInjectable);
export const vpaApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.verticalPodAutoscalerApiInjectable);
export const pdbApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.podDisruptionBudgetApiInjectable);
export const pcApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.priorityClassApiInjectable);
export const endpointApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.endpointsApiInjectable);
export const ingressApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.ingressApiInjectable);
export const networkPolicyApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.networkPolicyApiInjectable);
export const persistentVolumeApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.persistentVolumeApiInjectable);
export const pvcApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.persistentVolumeClaimApiInjectable);
export const storageClassApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.storageClassApiInjectable);
export const namespacesApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.namespaceApiInjectable);
export const eventApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.kubeEventApiInjectable);
export const roleBindingApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.roleBindingApiInjectable);
export const crdApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.customResourceDefinitionApiInjectable);
export * from "../common-api/k8s-api";

6
packages/core/src/features/cluster/workloads/overview/extension-api/order-of-workload-overview-details.test.tsx
View File

@ -5,7 +5,7 @@
import type { RenderResult } from "@testing-library/react";
import { getApplicationBuilder } from "../../../../../renderer/components/test-utils/get-application-builder";
import React from "react";
import getRandomIdInjectable from "../../../../../common/utils/get-random-id.injectable";
import { getRandomIdInjectionToken } from "@k8slens/random";
import { workloadOverviewDetailInjectionToken } from "../../../../../renderer/components/workloads-overview/workload-overview-details/workload-overview-detail-injection-token";
import { getInjectable } from "@ogre-tools/injectable";
import { computed, runInAction } from "mobx";
@ -17,8 +17,8 @@ describe("order of workload overview details", () => {
const builder = getApplicationBuilder();
builder.beforeWindowStart(({ windowDi }) => {
windowDi.unoverride(getRandomIdInjectable);
windowDi.permitSideEffects(getRandomIdInjectable);
windowDi.unoverride(getRandomIdInjectionToken);
windowDi.permitSideEffects(getRandomIdInjectionToken);
runInAction(() => {
windowDi.register(

2
packages/core/src/features/cluster/workloads/pods.test.tsx
View File

@ -10,7 +10,7 @@ import podStoreInjectable from "../../../renderer/components/workloads-pods/stor
import type { PodMetrics, PodStatus } from "@k8slens/kube-object";
import { Pod } from "@k8slens/kube-object";
import type { PodMetricsApi } from "@k8slens/kube-api";
import podMetricsApiInjectable from "../../../common/k8s-api/endpoints/pod-metrics.api.injectable";
import { podMetricsApiInjectable } from "@k8slens/kube-api-specifics";
import type { RequestMetrics } from "../../../common/k8s-api/endpoints/metrics.api/request-metrics.injectable";
import requestMetricsInjectable from "../../../common/k8s-api/endpoints/metrics.api/request-metrics.injectable";

6
packages/core/src/features/status-bar/status-bar-items-originating-from-extensions.test.tsx
View File

@ -6,7 +6,7 @@ import type { RenderResult } from "@testing-library/react";
import React from "react";
import type { ApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
import { getApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
import getRandomIdInjectable from "../../common/utils/get-random-id.injectable";
import { getRandomIdInjectionToken } from "@k8slens/random";
import type { FakeExtensionOptions } from "../../renderer/components/test-utils/get-extension-fake";
import { computed } from "mobx";
@ -17,8 +17,8 @@ describe("status-bar-items-originating-from-extensions", () => {
applicationBuilder = getApplicationBuilder();
applicationBuilder.beforeWindowStart(({ windowDi }) => {
windowDi.unoverride(getRandomIdInjectable);
windowDi.permitSideEffects(getRandomIdInjectable);
windowDi.unoverride(getRandomIdInjectionToken);
windowDi.permitSideEffects(getRandomIdInjectionToken);
});
});

4
packages/core/src/features/tray/clicking-tray-menu-item-originating-from-extension.test.ts
View File

@ -5,7 +5,7 @@
import type { ApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
import { getApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
import type { FakeExtensionOptions } from "../../renderer/components/test-utils/get-extension-fake";
import getRandomIdInjectable from "../../common/utils/get-random-id.injectable";
import { getRandomIdInjectionToken } from "@k8slens/random";
import logErrorInjectable from "../../common/log-error.injectable";
describe("clicking tray menu item originating from extension", () => {
@ -19,7 +19,7 @@ describe("clicking tray menu item originating from extension", () => {
logErrorMock = jest.fn();
mainDi.override(logErrorInjectable, () => logErrorMock);
mainDi.override(getRandomIdInjectable, () => () => "some-random-id");
mainDi.override(getRandomIdInjectionToken, () => () => "some-random-id");
});
await builder.render();

6
packages/core/src/features/tray/multiple-separators-originating-from-extension.test.ts
View File

@ -4,7 +4,7 @@
*/
import type { ApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
import { getApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
import getRandomIdInjectable from "../../common/utils/get-random-id.injectable";
import { getRandomIdInjectionToken } from "@k8slens/random";
describe("multiple separators originating from extension", () => {
let builder: ApplicationBuilder;
@ -13,8 +13,8 @@ describe("multiple separators originating from extension", () => {
builder = getApplicationBuilder();
builder.beforeApplicationStart(({ mainDi }) => {
mainDi.unoverride(getRandomIdInjectable);
mainDi.permitSideEffects(getRandomIdInjectable);
mainDi.unoverride(getRandomIdInjectionToken);
mainDi.permitSideEffects(getRandomIdInjectionToken);
});
await builder.render();

4
packages/core/src/main/getDiForUnitTesting.ts
View File

@ -29,6 +29,8 @@ import { registerMobX } from "@ogre-tools/injectable-extension-for-mobx";
import { registerFeature } from "@k8slens/feature-core";
import { messagingFeature, testUtils as messagingTestUtils } from "@k8slens/messaging";
import { loggerFeature } from "@k8slens/logger";
import { randomFeature } from "@k8slens/random";
import { kubeApiSpecificsFeature } from "@k8slens/kube-api-specifics";
export function getDiForUnitTesting() {
const environment = "main";
@ -44,6 +46,8 @@ export function getDiForUnitTesting() {
messagingFeature,
messagingTestUtils.messagingFeatureForUnitTesting,
loggerFeature,
randomFeature,
kubeApiSpecificsFeature,
);
});

2
packages/core/src/main/stores-apis-can-be-created.injectable.ts
View File

@ -3,7 +3,7 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import { storesAndApisCanBeCreatedInjectionToken } from "../common/k8s-api/stores-apis-can-be-created.token";
import { storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
const storesAndApisCanBeCreatedInjectable = getInjectable({
id: "create-stores-and-apis",

4
packages/core/src/main/tray/tray-menu-item/tray-menu-item-registrator.injectable.ts
View File

@ -14,7 +14,7 @@ import type { TrayMenuRegistration } from "../tray-menu-registration";
import { withErrorSuppression } from "../../../common/utils/with-error-suppression/with-error-suppression";
import type { WithErrorLoggingFor } from "../../../common/utils/with-error-logging/with-error-logging.injectable";
import withErrorLoggingInjectable from "../../../common/utils/with-error-logging/with-error-logging.injectable";
import getRandomIdInjectable from "../../../common/utils/get-random-id.injectable";
import { getRandomIdInjectionToken } from "@k8slens/random";
import { isBoolean, isString } from "@k8slens/utilities";
const trayMenuItemRegistratorInjectable = getInjectable({
@ -23,7 +23,7 @@ const trayMenuItemRegistratorInjectable = getInjectable({
instantiate: (di) => (extension) => {
const mainExtension = extension as LensMainExtension;
const withErrorLoggingFor = di.inject(withErrorLoggingInjectable);
const getRandomId = di.inject(getRandomIdInjectable);
const getRandomId = di.inject(getRandomIdInjectionToken);
return computed(() => {
const trayMenus = Array.isArray(mainExtension.trayMenus) ? mainExtension.trayMenus : mainExtension.trayMenus.get();

8
packages/core/src/renderer/before-frame-starts/runnables/setup-auto-crd-api-creations.injectable.ts
View File

@ -8,11 +8,11 @@ import { customResourceDefinitionApiInjectionToken } from "../../../common/k8s-a
import type { CustomResourceDefinition } from "@k8slens/kube-object";
import { KubeApi } from "@k8slens/kube-api";
import { KubeObject } from "@k8slens/kube-object";
import maybeKubeApiInjectable from "../../../common/k8s-api/maybe-kube-api.injectable";
import { loggerInjectionToken } from "@k8slens/logger";
import { logErrorInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
import { injectableDifferencingRegistratorWith } from "../../../common/utils/registrator-helper";
import customResourceDefinitionStoreInjectable from "../../components/custom-resource-definitions/store.injectable";
import { beforeClusterFrameStartsSecondInjectionToken } from "../tokens";
import { maybeKubeApiInjectable } from "@k8slens/kube-api-specifics";
const setupAutoCrdApiCreationsInjectable = getInjectable({
id: "setup-auto-crd-api-creations",
@ -45,7 +45,9 @@ const toCrdApiInjectable = (crd: CustomResourceDefinition) => getInjectable({
};
return new KubeApi({
logger: di.inject(loggerInjectionToken),
logError: di.inject(logErrorInjectionToken),
logInfo: di.inject(logInfoInjectionToken),
logWarn: di.inject(logWarningInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}, { objectConstructor });
},

5
packages/core/src/renderer/components/cluster/store.injectable.ts
View File

@ -6,8 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
import { ClusterStore } from "./store";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
import clusterApiInjectable from "../../../common/k8s-api/endpoints/cluster.api.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { clusterApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
import assert from "assert";
import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
import { loggerInjectionToken } from "@k8slens/logger";
@ -16,7 +15,7 @@ const clusterStoreInjectable = getInjectable({
id: "cluster-store",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectable), "clusterStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterStore is only available in certain environments");
const clusterApi = di.inject(clusterApiInjectable);
return new ClusterStore({

5
packages/core/src/renderer/components/config-horizontal-pod-autoscalers/store.injectable.ts
View File

@ -5,16 +5,15 @@
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
import horizontalPodAutoscalerApiInjectable from "../../../common/k8s-api/endpoints/horizontal-pod-autoscaler.api.injectable";
import { horizontalPodAutoscalerApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { HorizontalPodAutoscalerStore } from "./store";
const horizontalPodAutoscalerStoreInjectable = getInjectable({
id: "horizontal-pod-autoscaler-store",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectable), "horizontalPodAutoscalerStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "horizontalPodAutoscalerStore is only available in certain environments");
const api = di.inject(horizontalPodAutoscalerApiInjectable);

5
packages/core/src/renderer/components/config-leases/store.injectable.ts
View File

@ -5,16 +5,15 @@
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
import leaseApiInjectable from "../../../common/k8s-api/endpoints/lease.api.injectable";
import { leaseApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { LeaseStore } from "./store";
const leaseStoreInjectable = getInjectable({
id: "lease-store",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectable), "leaseStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "leaseStore is only available in certain environments");
const api = di.inject(leaseApiInjectable);

5
packages/core/src/renderer/components/config-limit-ranges/store.injectable.ts
View File

@ -5,16 +5,15 @@
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
import limitRangeApiInjectable from "../../../common/k8s-api/endpoints/limit-range.api.injectable";
import { limitRangeApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { LimitRangeStore } from "./store";
const limitRangeStoreInjectable = getInjectable({
id: "limit-range-store",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectable), "limitRangeStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "limitRangeStore is only available in certain environments");
const api = di.inject(limitRangeApiInjectable);

5
packages/core/src/renderer/components/config-maps/store.injectable.ts
View File

@ -5,16 +5,15 @@
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
import configMapApiInjectable from "../../../common/k8s-api/endpoints/config-map.api.injectable";
import { configMapApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { ConfigMapStore } from "./store";
const configMapStoreInjectable = getInjectable({
id: "config-map-store",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectable), "configMapStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "configMapStore is only available in certain environments");
const api = di.inject(configMapApiInjectable);

6
packages/core/src/renderer/components/config-mutating-webhook-configurations/mutating-webhook-configuration-store.injectable.ts
View File

@ -7,12 +7,14 @@ import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manag
import { MutatingWebhookConfigurationStore } from "./mutating-webhook-configuration-store";
import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
import { loggerInjectionToken } from "@k8slens/logger";
import mutatingWebhookConfigurationApiInjectable
from "../../../common/k8s-api/endpoints/mutating-webhook-configuration-api.injectable";
import { mutatingWebhookConfigurationApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
import assert from "assert";
const mutatingWebhookConfigurationStoreInjectable = getInjectable({
id: "mutating-webhook-configuration-store",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "mutatingWebhookConfigurationStore is only available in certain environments");
const api = di.inject(mutatingWebhookConfigurationApiInjectable);
return new MutatingWebhookConfigurationStore({

4
packages/core/src/renderer/components/config-pod-disruption-budgets/__tests__/pod-distruption-budgets.test.tsx
View File

@ -11,13 +11,13 @@ import { PodDisruptionBudgets } from "../pod-disruption-budgets";
import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
import selectedNamespacesStorageInjectable from "../../../../features/namespace-filtering/renderer/storage.injectable";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../../../../common/k8s-api/maybe-kube-api.injectable";
import podDisruptionBudgetStoreInjectable from "../store.injectable";
import siblingTabsInjectable from "../../../routes/sibling-tabs.injectable";
import { Cluster } from "../../../../common/cluster/cluster";
import hostedClusterInjectable from "../../../cluster-frame-context/hosted-cluster.injectable";
import userPreferencesStateInjectable from "../../../../features/user-preferences/common/state.injectable";
import type { DiContainer } from "@ogre-tools/injectable";
import { maybeKubeApiInjectable } from "@k8slens/kube-api-specifics";
describe("<PodDisruptionBudgets />", () => {
let di: DiContainer;
@ -60,7 +60,7 @@ describe("<PodDisruptionBudgets />", () => {
get: () => ({}),
}) as any);
di.override(loggerInjectionToken, () => null);
di.override(maybeKubeApiInjectable, () => (() => null) as any);
di.override(maybeKubeApiInjectable, () => ({}));
di.override(siblingTabsInjectable, () => ({ get: () => [] } as any));
di.override(userPreferencesStateInjectable, () => ({
hiddenTableColumns: {

5
packages/core/src/renderer/components/config-pod-disruption-budgets/store.injectable.ts
View File

@ -5,16 +5,15 @@
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
import podDisruptionBudgetApiInjectable from "../../../common/k8s-api/endpoints/pod-disruption-budget.api.injectable";
import { podDisruptionBudgetApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { PodDisruptionBudgetStore } from "./store";
const podDisruptionBudgetStoreInjectable = getInjectable({
id: "pod-disruption-budget-store",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectable), "podDisruptionBudgetStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podDisruptionBudgetStore is only available in certain environments");
const api = di.inject(podDisruptionBudgetApiInjectable);

5
packages/core/src/renderer/components/config-priority-classes/store.injectable.ts
View File

@ -5,16 +5,15 @@
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
import priorityClassApiInjectable from "../../../common/k8s-api/endpoints/priority-class.api.injectable";
import { priorityClassApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { PriorityClassStore } from "./store";
const priorityClassStoreInjectable = getInjectable({
id: "priority-class-store",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectable), "priorityClassStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "priorityClassStore is only available in certain environments");
const api = di.inject(priorityClassApiInjectable);

2
packages/core/src/renderer/components/config-resource-quotas/add-dialog/view.tsx
View File

@ -24,7 +24,7 @@ import { SubTitle } from "../../layout/sub-title";
import { withInjectables } from "@ogre-tools/injectable-react";
import closeAddQuotaDialogInjectable from "./close.injectable";
import isAddQuotaDialogOpenInjectable from "./is-open.injectable";
import resourceQuotaApiInjectable from "../../../../common/k8s-api/endpoints/resource-quota.api.injectable";
import { resourceQuotaApiInjectable } from "@k8slens/kube-api-specifics";
import type { ShowCheckedErrorNotification } from "../../notifications/show-checked-error.injectable";
import showCheckedErrorNotificationInjectable from "../../notifications/show-checked-error.injectable";

5
packages/core/src/renderer/components/config-resource-quotas/store.injectable.ts
View File

@ -5,16 +5,15 @@
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
import resourceQuotaApiInjectable from "../../../common/k8s-api/endpoints/resource-quota.api.injectable";
import { resourceQuotaApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { ResourceQuotaStore } from "./store";
const resourceQuotaStoreInjectable = getInjectable({
id: "resource-quota-store",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectable), "resourceQuotaStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "resourceQuotaStore is only available in certain environments");
const api = di.inject(resourceQuotaApiInjectable);

5
packages/core/src/renderer/components/config-runtime-classes/store.injectable.ts
View File

@ -5,16 +5,15 @@
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
import runtimeClassApiInjectable from "../../../common/k8s-api/endpoints/runtime-class.api.injectable";
import { runtimeClassApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { RuntimeClassStore } from "./store";
const runtimeClassStoreInjectable = getInjectable({
id: "runtime-class-store",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectable), "runtimeClassStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "runtimeClassStore is only available in certain environments");
const api = di.inject(runtimeClassApiInjectable);

2
packages/core/src/renderer/components/config-secrets/add-dialog/view.tsx
View File

@ -25,7 +25,7 @@ import upperFirst from "lodash/upperFirst";
import type { ShowDetails } from "../../kube-detail-params/show-details.injectable";
import { withInjectables } from "@ogre-tools/injectable-react";
import closeAddSecretDialogInjectable from "./close.injectable";
import secretApiInjectable from "../../../../common/k8s-api/endpoints/secret.api.injectable";
import { secretApiInjectable } from "@k8slens/kube-api-specifics";
import showDetailsInjectable from "../../kube-detail-params/show-details.injectable";
import isAddSecretDialogOpenInjectable from "./is-open.injectable";
import type { ShowCheckedErrorNotification } from "../../notifications/show-checked-error.injectable";

5
packages/core/src/renderer/components/config-secrets/store.injectable.ts
View File

@ -5,16 +5,15 @@
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
import secretApiInjectable from "../../../common/k8s-api/endpoints/secret.api.injectable";
import { secretApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { SecretStore } from "./store";
const secretStoreInjectable = getInjectable({
id: "secret-store",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectable), "secretStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "secretStore is only available in certain environments");
const api = di.inject(secretApiInjectable);

6
packages/core/src/renderer/components/config-validating-webhook-configurations/validating-webhook-configuration-store.injectable.ts
View File

@ -7,12 +7,14 @@ import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manag
import { ValidatingWebhookConfigurationStore } from "./validating-webhook-configuration-store";
import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
import { loggerInjectionToken } from "@k8slens/logger";
import validatingWebhookConfigurationApiInjectable
from "../../../common/k8s-api/endpoints/validating-webhook-configuration-api.injectable";
import { storesAndApisCanBeCreatedInjectionToken, validatingWebhookConfigurationApiInjectable } from "@k8slens/kube-api-specifics";
import assert from "assert";
const validatingWebhookConfigurationStoreInjectable = getInjectable({
id: "validating-webhook-configuration-store",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "validatingWebhookConfigurationStore is only available in certain environments");
const api = di.inject(validatingWebhookConfigurationApiInjectable);
return new ValidatingWebhookConfigurationStore({

5
packages/core/src/renderer/components/config-vertical-pod-autoscalers/store.injectable.ts
View File

@ -6,15 +6,14 @@ import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { loggerInjectionToken } from "@k8slens/logger";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
import verticalPodAutoscalerApiInjectable from "../../../common/k8s-api/endpoints/vertical-pod-autoscaler.api.injectable";
import { storesAndApisCanBeCreatedInjectionToken, verticalPodAutoscalerApiInjectable } from "@k8slens/kube-api-specifics";
import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { VerticalPodAutoscalerStore } from "./store";
const verticalPodAutoscalerStoreInjectable = getInjectable({
id: "vertical-pod-autoscaler-store",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectable), "verticalPodAutoscalerStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "verticalPodAutoscalerStore is only available in certain environments");
const api = di.inject(verticalPodAutoscalerApiInjectable);

4
packages/core/src/renderer/components/custom-resource-definitions/definitions.injectable.ts
View File

@ -5,15 +5,15 @@
import { getInjectable } from "@ogre-tools/injectable";
import { computed } from "mobx";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import subscribeStoresInjectable from "../../kube-watch-api/subscribe-stores.injectable";
import customResourceDefinitionStoreInjectable from "./store.injectable";
import { storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
const customResourceDefinitionsInjectable = getInjectable({
id: "custom-resource-definitions",
instantiate: (di) => {
const createStoresAndApis = di.inject(storesAndApisCanBeCreatedInjectable);
const createStoresAndApis = di.inject(storesAndApisCanBeCreatedInjectionToken);
if (!createStoresAndApis) {
return computed(() => []);

5
packages/core/src/renderer/components/custom-resource-definitions/store.injectable.ts
View File

@ -5,16 +5,15 @@
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
import customResourceDefinitionApiInjectable from "../../../common/k8s-api/endpoints/custom-resource-definition.api.injectable";
import { customResourceDefinitionApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { CustomResourceDefinitionStore } from "./store";
const customResourceDefinitionStoreInjectable = getInjectable({
id: "custom-resource-definition-store",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectable), "customResourceDefinitionStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "customResourceDefinitionStore is only available in certain environments");
const api = di.inject(customResourceDefinitionApiInjectable);

4
packages/core/src/renderer/components/dock/edit-resource/get-random-id-for-edit-resource-tab.injectable.ts
View File

@ -3,11 +3,11 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import getRandomIdInjectable from "../../../../common/utils/get-random-id.injectable";
import { getRandomIdInjectionToken } from "@k8slens/random";
const getRandomIdForEditResourceTabInjectable = getInjectable({
id: "get-random-id-for-edit-resource-tab",
instantiate: (di) => di.inject(getRandomIdInjectable),
instantiate: (di) => di.inject(getRandomIdInjectionToken),
});
export default getRandomIdForEditResourceTabInjectable;

4
packages/core/src/renderer/components/dock/install-chart/get-random-install-chart-tab-id.injectable.ts
View File

@ -3,11 +3,11 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import getRandomIdInjectable from "../../../../common/utils/get-random-id.injectable";
import { getRandomIdInjectionToken } from "@k8slens/random";
const getRandomInstallChartTabIdInjectable = getInjectable({
id: "get-random-install-chart-tab-id",
instantiate: (di) => di.inject(getRandomIdInjectable),
instantiate: (di) => di.inject(getRandomIdInjectionToken),
});
export default getRandomInstallChartTabIdInjectable;

2
packages/core/src/renderer/components/dock/logs/call-for-logs.injectable.ts
View File

@ -4,7 +4,7 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import type { PodLogsQuery } from "@k8slens/kube-object";
import podApiInjectable from "../../../../common/k8s-api/endpoints/pod.api.injectable";
import { podApiInjectable } from "@k8slens/kube-api-specifics";
import type { ResourceDescriptor } from "@k8slens/kube-api";
export type CallForLogs = (params: ResourceDescriptor, query?: PodLogsQuery) => Promise<string>;

4
packages/core/src/renderer/components/dock/logs/get-random-id-for-pod-logs-tab.injectable.ts
View File

@ -3,11 +3,11 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import getRandomIdInjectable from "../../../../common/utils/get-random-id.injectable";
import { getRandomIdInjectionToken } from "@k8slens/random";
const getRandomIdForPodLogsTabInjectable = getInjectable({
id: "get-random-id-for-pod-logs-tab",
instantiate: (di) => di.inject(getRandomIdInjectable),
instantiate: (di) => di.inject(getRandomIdInjectionToken),
});
export default getRandomIdForPodLogsTabInjectable;

4
packages/core/src/renderer/components/dock/upgrade-chart/get-random-upgrade-chart-tab-id.injectable.ts
View File

@ -3,11 +3,11 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import getRandomIdInjectable from "../../../../common/utils/get-random-id.injectable";
import { getRandomIdInjectionToken } from "@k8slens/random";
const getRandomUpgradeChartTabIdInjectable = getInjectable({
id: "get-random-upgrade-chart-tab-id",
instantiate: (di) => di.inject(getRandomIdInjectable),
instantiate: (di) => di.inject(getRandomIdInjectionToken),
});
export default getRandomUpgradeChartTabIdInjectable;

5
packages/core/src/renderer/components/events/store.injectable.ts
View File

@ -6,16 +6,15 @@ import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import getPodByIdInjectable from "../workloads-pods/get-pod-by-id.injectable";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
import kubeEventApiInjectable from "../../../common/k8s-api/endpoints/events.api.injectable";
import { kubeEventApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { EventStore } from "./store";
const eventStoreInjectable = getInjectable({
id: "event-store",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectable), "eventStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "eventStore is only available in certain environments");
const api = di.inject(kubeEventApiInjectable);

4
packages/core/src/renderer/components/kube-object-details/kube-object-detail-items/kube-object-detail-item-registrator.injectable.ts
View File

@ -4,7 +4,7 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import { computed } from "mobx";
import getRandomIdInjectable from "../../../../common/utils/get-random-id.injectable";
import { getRandomIdInjectionToken } from "@k8slens/random";
import type { LensRendererExtension } from "../../../../extensions/lens-renderer-extension";
import extensionShouldBeEnabledForClusterFrameInjectable from "../../../extension-loader/extension-should-be-enabled-for-cluster-frame.injectable";
import { kubeObjectDetailItemInjectionToken } from "./kube-object-detail-item-injection-token";
@ -16,7 +16,7 @@ const kubeObjectDetailItemRegistratorInjectable = getInjectable({
id: "kube-object-detail-item-registrator",
instantiate: (di) => {
const getRandomId = di.inject(getRandomIdInjectable);
const getRandomId = di.inject(getRandomIdInjectionToken);
const getExtensionShouldBeEnabledForClusterFrame = (
extension: LensRendererExtension,

4
packages/core/src/renderer/components/kube-object-menu/kube-object-menu-item-registrator.injectable.ts
View File

@ -5,7 +5,7 @@
import { getInjectable } from "@ogre-tools/injectable";
import { extensionRegistratorInjectionToken } from "../../../extensions/extension-loader/extension-registrator-injection-token";
import type { LensRendererExtension } from "../../../extensions/lens-renderer-extension";
import getRandomIdInjectable from "../../../common/utils/get-random-id.injectable";
import { getRandomIdInjectionToken } from "@k8slens/random";
import extensionShouldBeEnabledForClusterFrameInjectable from "../../extension-loader/extension-should-be-enabled-for-cluster-frame.injectable";
import { kubeObjectMenuItemInjectionToken } from "./kube-object-menu-item-injection-token";
import { computed } from "mobx";
@ -14,7 +14,7 @@ const kubeObjectMenuItemRegistratorInjectable = getInjectable({
id: "kube-object-menu-item-registrator",
instantiate: (di) => {
const getRandomId = di.inject(getRandomIdInjectable);
const getRandomId = di.inject(getRandomIdInjectionToken);
const getExtensionShouldBeEnabledForClusterFrame = (
extension: LensRendererExtension,

2
packages/core/src/renderer/components/kube-object-meta/kube-object-meta.tsx
View File

@ -20,7 +20,7 @@ import getDetailsUrlInjectable from "../kube-detail-params/get-details-url.injec
import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
import { loggerInjectionToken } from "@k8slens/logger";
import type { NamespaceApi } from "@k8slens/kube-api";
import namespaceApiInjectable from "../../../common/k8s-api/endpoints/namespace.api.injectable";
import { namespaceApiInjectable } from "@k8slens/kube-api-specifics";
export interface KubeObjectMetaProps {
object: KubeObject;

4
packages/core/src/renderer/components/kube-object-status-icon/kube-object-status-text-registrator.injectable.ts
View File

@ -5,7 +5,7 @@
import { getInjectable } from "@ogre-tools/injectable";
import { extensionRegistratorInjectionToken } from "../../../extensions/extension-loader/extension-registrator-injection-token";
import type { LensRendererExtension } from "../../../extensions/lens-renderer-extension";
import getRandomIdInjectable from "../../../common/utils/get-random-id.injectable";
import { getRandomIdInjectionToken } from "@k8slens/random";
import { kubeObjectStatusTextInjectionToken } from "./kube-object-status-text-injection-token";
import extensionShouldBeEnabledForClusterFrameInjectable from "../../extension-loader/extension-should-be-enabled-for-cluster-frame.injectable";
import { computed } from "mobx";
@ -14,7 +14,7 @@ const kubeObjectStatusTextRegistratorInjectable = getInjectable({
id: "kube-object-status-text-registrator",
instantiate: (di) => {
const getRandomId = di.inject(getRandomIdInjectable);
const getRandomId = di.inject(getRandomIdInjectionToken);
const getExtensionShouldBeEnabledForClusterFrame = (
extension: LensRendererExtension,

4
packages/core/src/renderer/components/menu/menu-actions.tsx
View File

@ -19,7 +19,7 @@ import type { TooltipDecoratorProps } from "@k8slens/tooltip";
import type { OpenConfirmDialog } from "../confirm-dialog/open.injectable";
import { withInjectables } from "@ogre-tools/injectable-react";
import openConfirmDialogInjectable from "../confirm-dialog/open.injectable";
import getRandomIdInjectable from "../../../common/utils/get-random-id.injectable";
import { getRandomIdInjectionToken } from "@k8slens/random";
import autoBindReact from "auto-bind/react";
export interface MenuActionsProps extends Partial<MenuProps> {
@ -186,7 +186,7 @@ class NonInjectedMenuActions extends React.Component<MenuActionsProps & Dependen
export const MenuActions = withInjectables<Dependencies, MenuActionsProps>(NonInjectedMenuActions, {
getProps: (di, props) => ({
id: di.inject(getRandomIdInjectable)(),
id: di.inject(getRandomIdInjectionToken)(),
openConfirmDialog: di.inject(openConfirmDialogInjectable),
...props,
}),

5
packages/core/src/renderer/components/namespaces/store.injectable.ts
View File

@ -5,9 +5,8 @@
import { getInjectable } from "@ogre-tools/injectable";
import { NamespaceStore } from "./store";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
import namespaceApiInjectable from "../../../common/k8s-api/endpoints/namespace.api.injectable";
import { namespaceApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
import assert from "assert";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
import clusterConfiguredAccessibleNamespacesInjectable from "../../cluster/accessible-namespaces.injectable";
import { loggerInjectionToken } from "@k8slens/logger";
@ -17,7 +16,7 @@ const namespaceStoreInjectable = getInjectable({
id: "namespace-store",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectable), "namespaceStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "namespaceStore is only available in certain environments");
const api = di.inject(namespaceApiInjectable);

5
packages/core/src/renderer/components/network-endpoints/store.injectable.ts
View File

@ -5,16 +5,15 @@
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
import endpointsApiInjectable from "../../../common/k8s-api/endpoints/endpoint.api.injectable";
import { endpointsApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { EndpointsStore } from "./store";
const endpointsStoreInjectable = getInjectable({
id: "endpoints-store",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectable), "endpointsStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "endpointsStore is only available in certain environments");
const api = di.inject(endpointsApiInjectable);

2
packages/core/src/renderer/components/network-ingresses/ingress-class-set-default.injectable.ts
View File

@ -4,7 +4,7 @@
*/
import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
import type { IngressClass } from "@k8slens/kube-object";
import ingressClassApiInjectable from "../../../common/k8s-api/endpoints/ingress-class.api.injectable";
import { ingressClassApiInjectable } from "@k8slens/kube-api-specifics";
import ingressClassStoreInjectable from "./ingress-class-store.injectable";
export const ingressClassSetDefaultInjectable = getInjectable({

5
packages/core/src/renderer/components/network-ingresses/ingress-class-store.injectable.ts
View File

@ -5,9 +5,8 @@
import assert from "assert";
import { getInjectable } from "@ogre-tools/injectable";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
import ingressClassApiInjectable from "../../../common/k8s-api/endpoints/ingress-class.api.injectable";
import { ingressClassApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
import { IngressClassStore } from "./ingress-class-store";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
import { loggerInjectionToken } from "@k8slens/logger";
@ -15,7 +14,7 @@ const ingressClassStoreInjectable = getInjectable({
id: "ingress-class-store",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectable), "ingressClassStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "ingressClassStore is only available in certain environments");
const api = di.inject(ingressClassApiInjectable);

5
packages/core/src/renderer/components/network-ingresses/ingress-store.injectable.ts
View File

@ -5,16 +5,15 @@
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
import ingressApiInjectable from "../../../common/k8s-api/endpoints/ingress.api.injectable";
import { ingressApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { IngressStore } from "./ingress-store";
const ingressStoreInjectable = getInjectable({
id: "ingress-store",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectable), "ingressStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "ingressStore is only available in certain environments");
const api = di.inject(ingressApiInjectable);

5
packages/core/src/renderer/components/network-policies/store.injectable.ts
View File

@ -5,16 +5,15 @@
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
import networkPolicyApiInjectable from "../../../common/k8s-api/endpoints/network-policy.api.injectable";
import { networkPolicyApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { NetworkPolicyStore } from "./store";
const networkPolicyStoreInjectable = getInjectable({
id: "network-policy-store",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectable), "networkPolicyStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "networkPolicyStore is only available in certain environments");
const api = di.inject(networkPolicyApiInjectable);

3
packages/core/src/renderer/components/network-port-forwards/port-forward-details.tsx
View File

@ -14,10 +14,9 @@ import { cssNames } from "@k8slens/utilities";
import type { PodApi, ServiceApi } from "@k8slens/kube-api";
import { PortForwardMenu } from "./port-forward-menu";
import { withInjectables } from "@ogre-tools/injectable-react";
import serviceApiInjectable from "../../../common/k8s-api/endpoints/service.api.injectable";
import { serviceApiInjectable, podApiInjectable } from "@k8slens/kube-api-specifics";
import type { GetDetailsUrl } from "../kube-detail-params/get-details-url.injectable";
import getDetailsUrlInjectable from "../kube-detail-params/get-details-url.injectable";
import podApiInjectable from "../../../common/k8s-api/endpoints/pod.api.injectable";
export interface PortForwardDetailsProps {
portForward: PortForwardItem;

5
packages/core/src/renderer/components/network-services/store.injectable.ts
View File

@ -5,16 +5,15 @@
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
import serviceApiInjectable from "../../../common/k8s-api/endpoints/service.api.injectable";
import { serviceApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { ServiceStore } from "./store";
const serviceStoreInjectable = getInjectable({
id: "service-store",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectable), "serviceStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "serviceStore is only available in certain environments");
const api = di.inject(serviceApiInjectable);

5
packages/core/src/renderer/components/nodes/store.injectable.ts
View File

@ -5,16 +5,15 @@
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
import nodeApiInjectable from "../../../common/k8s-api/endpoints/node.api.injectable";
import { nodeApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { NodeStore } from "./store";
const nodeStoreInjectable = getInjectable({
id: "node-store",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectable), "nodeStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "nodeStore is only available in certain environments");
const api = di.inject(nodeApiInjectable);

5
packages/core/src/renderer/components/pod-security-policies/store.injectable.ts
View File

@ -5,16 +5,15 @@
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
import podSecurityPolicyApiInjectable from "../../../common/k8s-api/endpoints/pod-security-policy.api.injectable";
import { podSecurityPolicyApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { PodSecurityPolicyStore } from "./store";
const podSecurityPolicyStoreInjectable = getInjectable({
id: "pod-security-policy-store",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectable), "podSecurityPolicyStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podSecurityPolicyStore is only available in certain environments");
const api = di.inject(podSecurityPolicyApiInjectable);

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