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

chore: loggerInjectionToken

Browse Source 
Signed-off-by: Gabriel <gaccettola@mirantis.com>
This commit is contained in:
Gabriel 2023-05-02 22:16:23 +02:00 committed by Sebastian Malton
parent 66f28046b9
commit 908d6b381d
244 changed files with 533 additions and 487 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
packages/core/src/common/cluster/create-can-i.injectable.ts
View File

@ -5,7 +5,7 @@
import type { AuthorizationV1Api, V1ResourceAttributes } from "@kubernetes/client-node";
import { getInjectable } from "@ogre-tools/injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
/**
* Requests the permissions for actions on the kube cluster
@ -19,7 +19,7 @@ export type CreateCanI = (api: AuthorizationV1Api) => CanI;
const createCanIInjectable = getInjectable({
id: "create-can-i",
instantiate: (di): CreateCanI => {
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return (api) => async (resourceAttributes: V1ResourceAttributes): Promise<boolean> => {
try {

4
packages/core/src/common/cluster/create-request-namespace-list-permissions.injectable.ts
View File

@ -5,7 +5,7 @@
import type { AuthorizationV1Api } from "@kubernetes/client-node";
import { getInjectable } from "@ogre-tools/injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import type { KubeApiResource } from "../rbac";
export type CanListResource = (resource: KubeApiResource) => boolean;
@ -21,7 +21,7 @@ export type CreateRequestNamespaceListPermissions = (api: AuthorizationV1Api) =>
const createRequestNamespaceListPermissionsInjectable = getInjectable({
id: "create-request-namespace-list-permissions",
instantiate: (di): CreateRequestNamespaceListPermissions => {
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return (api) => async (namespace) => {
try {

4
packages/core/src/common/ipc/ipc.ts
View File

@ -12,7 +12,7 @@ import { toJS } from "../utils/toJS";
import type { Disposer } from "@k8slens/utilities";
import { getLegacyGlobalDiForExtensionApi } from "@k8slens/legacy-global-di";
import ipcRendererInjectable from "../../renderer/utils/channel/ipc-renderer.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import ipcMainInjectionToken from "./ipc-main-injection-token";
import clusterFramesInjectable from "../cluster-frames.injectable";
@ -38,7 +38,7 @@ export async function broadcastMessage(channel: string, ...args: any[]): Promise
}
const di = getLegacyGlobalDiForExtensionApi();
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
const clusterFrames = di.inject(clusterFramesInjectable);
ipcMain.listeners(channel).forEach((func) => func({

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

@ -11,7 +11,7 @@ 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 { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import type { ApiManager } from "../api-manager";
import apiManagerInjectable from "../api-manager/manager.injectable";
import { KubeApi } from "../kube-api";
@ -61,7 +61,7 @@ describe("ApiManager", () => {
const apiBase = "apis/v1/foo";
const fallbackApiBase = "/apis/extensions/v1beta1/foo";
const kubeApi = new TestApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}, {
objectConstructor: KubeObject,
@ -72,7 +72,7 @@ describe("ApiManager", () => {
});
const kubeStore = new TestStore({
context: di.inject(clusterFrameContextForNamespacedResourcesInjectable),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
}, kubeApi);
apiManager.registerApi(kubeApi);
@ -136,7 +136,7 @@ describe("ApiManager", () => {
return Object.assign(
new KubeApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}, { objectConstructor }),
{
@ -189,7 +189,7 @@ describe("ApiManager", () => {
apiManager.registerStore(Object.assign(
new KubeObjectStore({
context: di.inject(clusterFrameContextForNamespacedResourcesInjectable),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
}, api),
{
someField: 2,

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

@ -21,7 +21,7 @@ import directoryForKubeConfigsInjectable from "../../app-paths/directory-for-kub
import apiManagerInjectable from "../api-manager/manager.injectable";
import type { DiContainer } from "@ogre-tools/injectable";
import ingressApiInjectable from "../endpoints/ingress.api.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
import { Cluster } from "../../cluster/cluster";
@ -710,7 +710,7 @@ describe("KubeApi", () => {
beforeEach(async () => {
horizontalPodAutoscalerApi = new HorizontalPodAutoscalerApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}, {
allowedUsableVersions: {

4
packages/core/src/common/k8s-api/api-manager/create-custom-resource-store.injectable.ts
View File

@ -4,7 +4,7 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import clusterFrameContextForNamespacedResourcesInjectable from "../../../renderer/cluster-frame-context/for-namespaced-resources.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import type { KubeApi } from "../kube-api";
import type { KubeObject } from "@k8slens/kube-object";
import type { KubeObjectStoreDependencies } from "../kube-object.store";
@ -17,7 +17,7 @@ const createCustomResourceStoreInjectable = getInjectable({
instantiate: (di): CreateCustomResourceStore => {
const deps: KubeObjectStoreDependencies = {
context: di.inject(clusterFrameContextForNamespacedResourcesInjectable),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
};
return (api) => new CustomResourceStore(deps, api);

4
packages/core/src/common/k8s-api/create-json-api.injectable.ts
View File

@ -7,7 +7,7 @@ import { Agent } from "https";
import type { RequestInit } from "@k8slens/node-fetch";
import lensProxyCertificateInjectable from "../certificate/lens-proxy-certificate.injectable";
import fetchInjectable from "../fetch/fetch.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import type { JsonApiConfig, JsonApiData, JsonApiDependencies, JsonApiParams } from "./json-api";
import { JsonApi } from "./json-api";
@ -18,7 +18,7 @@ const createJsonApiInjectable = getInjectable({
instantiate: (di): CreateJsonApi => {
const deps: JsonApiDependencies = {
fetch: di.inject(fetchInjectable),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
};
const lensProxyCert = di.inject(lensProxyCertificateInjectable);

4
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 { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import { apiKubePrefix } from "../vars";
import isDevelopmentInjectable from "../vars/is-development.injectable";
import apiBaseInjectable from "./api-base.injectable";
@ -37,7 +37,7 @@ const createKubeApiForClusterInjectable = getInjectable({
const apiBase = di.inject(apiBaseInjectable);
const isDevelopment = di.inject(isDevelopmentInjectable);
const createKubeJsonApi = di.inject(createKubeJsonApiInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return (
cluster: CreateKubeApiForLocalClusterConfig,

4
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 { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import isDevelopmentInjectable from "../vars/is-development.injectable";
import createKubeJsonApiInjectable from "./create-kube-json-api.injectable";
import type { KubeApiOptions } from "./kube-api";
@ -53,7 +53,7 @@ const createKubeApiForRemoteClusterInjectable = getInjectable({
instantiate: (di): CreateKubeApiForRemoteCluster => {
const isDevelopment = di.inject(isDevelopmentInjectable);
const createKubeJsonApi = di.inject(createKubeJsonApiInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return (
config: CreateKubeApiForRemoteClusterConfig,

4
packages/core/src/common/k8s-api/create-kube-api.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 { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import type { DerivedKubeApiOptions, KubeApiDependencies } from "./kube-api";
import maybeKubeApiInjectable from "./maybe-kube-api.injectable";
@ -15,7 +15,7 @@ const createKubeApiInjectable = getInjectable({
id: "create-kube-api",
instantiate: (di): CreateKubeApi => {
const deps: KubeApiDependencies = {
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
};

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

@ -7,7 +7,7 @@ import { Agent } from "https";
import type { RequestInit } from "@k8slens/node-fetch";
import lensProxyCertificateInjectable from "../certificate/lens-proxy-certificate.injectable";
import fetchInjectable from "../fetch/fetch.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import type { JsonApiConfig, JsonApiDependencies } from "./json-api";
import { KubeJsonApi } from "./kube-json-api";
@ -18,7 +18,7 @@ const createKubeJsonApiInjectable = getInjectable({
instantiate: (di): CreateKubeJsonApi => {
const dependencies: JsonApiDependencies = {
fetch: di.inject(fetchInjectable),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
};
const lensProxyCert = di.inject(lensProxyCertificateInjectable);

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ClusterRoleBindingApi } from "./cluster-role-binding.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const clusterRoleBindingApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const clusterRoleBindingApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterRoleBindingApi is only accessible in certain environments");
return new ClusterRoleBindingApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ClusterRoleApi } from "./cluster-role.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const clusterRoleApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const clusterRoleApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterRoleApi is only available in certain environments");
return new ClusterRoleApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ClusterApi } from "./cluster.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const clusterApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const clusterApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterApi is only available in certain environments");
return new ClusterApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -8,7 +8,7 @@ import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-c
import { ComponentStatusApi } from "./component-status.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
const componentStatusApiInjectable = getInjectable({
id: "component-status-api",
@ -16,7 +16,7 @@ const componentStatusApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "componentStatusApi is only available in certain environments");
return new ComponentStatusApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ConfigMapApi } from "./config-map.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const configMapApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const configMapApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "configMapApi is only available in certain environments");
return new ConfigMapApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { CronJobApi } from "./cron-job.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const cronJobApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const cronJobApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "cronJobApi is only available in certain environments");
return new CronJobApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}, {
checkPreferredVersion: true,

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

@ -8,7 +8,7 @@ import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-c
import { CustomResourceDefinitionApi } from "./custom-resource-definition.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
const customResourceDefinitionApiInjectable = getInjectable({
id: "custom-resource-definition-api",
@ -16,7 +16,7 @@ const customResourceDefinitionApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "customResourceDefinitionApi is only available in certain environments");
return new CustomResourceDefinitionApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { DaemonSetApi } from "./daemon-set.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const daemonSetApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const daemonSetApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "daemonSetApi is only available in certain environments");
return new DaemonSetApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { DeploymentApi } from "./deployment.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const deploymentApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const deploymentApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "deploymentApi is only available in certain environments");
return new DeploymentApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { EndpointsApi } from "./endpoint.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const endpointsApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const endpointsApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "endpointsApi is only available in certain environments");
return new EndpointsApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { KubeEventApi } from "./events.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const kubeEventApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const kubeEventApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "kubeEventApi is only available in certain environments");
return new KubeEventApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { HorizontalPodAutoscalerApi } from "./horizontal-pod-autoscaler.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const horizontalPodAutoscalerApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const horizontalPodAutoscalerApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "horizontalPodAutoscalerApi is only available in certain environments");
return new HorizontalPodAutoscalerApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -5,13 +5,13 @@
import { getInjectable } from "@ogre-tools/injectable";
import { IngressClassApi } from "./ingress-class.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
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(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}),

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { IngressApi } from "./ingress.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const ingressApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const ingressApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "ingressApi is only available in certain environments");
return new IngressApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { JobApi } from "./job.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const jobApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const jobApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "jobApi is only available in certain environments");
return new JobApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}, {
checkPreferredVersion: true,

4
packages/core/src/common/k8s-api/endpoints/lease.api.injectable.ts
View File

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { LeaseApi } from "./lease.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const leaseApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const leaseApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "leaseApi is only available in certain environments");
return new LeaseApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { LimitRangeApi } from "./limit-range.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const limitRangeApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const limitRangeApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "limitRangeApi is only available in certain environments");
return new LimitRangeApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -6,7 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
import { MutatingWebhookConfigurationApi } from "./mutating-webhook-configuration.api";
@ -16,7 +16,7 @@ const mutatingWebhookConfigurationApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "mutatingWebhookApi is only available in certain environments");
return new MutatingWebhookConfigurationApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { NamespaceApi } from "./namespace.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const namespaceApiInjectable = getInjectable({
@ -17,7 +17,7 @@ const namespaceApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "namespaceApi is only available in certain environments");
return new NamespaceApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { NetworkPolicyApi } from "./network-policy.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const networkPolicyApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const networkPolicyApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "networkPolicyApi is only available in certain environments");
return new NetworkPolicyApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

4
packages/core/src/common/k8s-api/endpoints/node.api.injectable.ts
View File

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { NodeApi } from "./node.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const nodeApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const nodeApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "nodeApi is only available in certain environments");
return new NodeApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PersistentVolumeClaimApi } from "./persistent-volume-claim.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const persistentVolumeClaimApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const persistentVolumeClaimApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "persistentVolumeClaimApi is only available in certain environments");
return new PersistentVolumeClaimApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PersistentVolumeApi } from "./persistent-volume.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const persistentVolumeApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const persistentVolumeApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "persistentVolumeApi is only available in certain environments");
return new PersistentVolumeApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PodDisruptionBudgetApi } from "./pod-disruption-budget.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const podDisruptionBudgetApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const podDisruptionBudgetApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podDisruptionBudgetApi is only available in certain environments");
return new PodDisruptionBudgetApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}, {
checkPreferredVersion: true,

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PodMetricsApi } from "./pod-metrics.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const podMetricsApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const podMetricsApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podMetricsApi is only available in certain environments");
return new PodMetricsApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PodSecurityPolicyApi } from "./pod-security-policy.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const podSecurityPolicyApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const podSecurityPolicyApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podSecurityPolicyApi is only available in certain environments");
return new PodSecurityPolicyApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PodApi } from "./pod.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const podApiInjectable = getInjectable({
@ -17,7 +17,7 @@ const podApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podApi is only available in certain environments");
return new PodApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PriorityClassApi } from "./priority-class.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const priorityClassApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const priorityClassApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "PriorityClassApi is only available in certain environments");
return new PriorityClassApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ReplicaSetApi } from "./replica-set.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const replicaSetApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const replicaSetApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "replicaSetApi is only available in certain environments");
return new ReplicaSetApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -4,7 +4,7 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
import { ReplicationControllerApi } from "./replication-controller.api";
@ -12,7 +12,7 @@ const replicationControllerApiInjectable = getInjectable({
id: "replication-controller-api",
instantiate: (di) => {
return new ReplicationControllerApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ResourceQuotaApi } from "./resource-quota.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const resourceQuotaApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const resourceQuotaApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "resourceQuotaApi is only available in certain environments");
return new ResourceQuotaApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { RoleBindingApi } from "./role-binding.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const roleBindingApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const roleBindingApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "roleBindingApi is only available in certain environments");
return new RoleBindingApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { RoleApi } from "./role.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const roleApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const roleApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "roleApi is only available in certain environments");
return new RoleApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { RuntimeClassApi } from "./runtime-class.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const runtimeClassApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const runtimeClassApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "RuntimeClassApi is only available in certain environments");
return new RuntimeClassApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

4
packages/core/src/common/k8s-api/endpoints/secret.api.injectable.ts
View File

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { SecretApi } from "./secret.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const secretApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const secretApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "secretApi is only available in certain environments");
return new SecretApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { SelfSubjectRulesReviewApi } from "./self-subject-rules-reviews.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const selfSubjectRulesReviewApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const selfSubjectRulesReviewApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "selfSubjectRulesReviewApi is only available in certain environments");
return new SelfSubjectRulesReviewApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ServiceAccountApi } from "./service-account.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const serviceAccountApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const serviceAccountApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "serviceAccountApi is only available in certain environments");
return new ServiceAccountApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ServiceApi } from "./service.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const serviceApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const serviceApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "serviceApi is only available in certain environments");
return new ServiceApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { StatefulSetApi } from "./stateful-set.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const statefulSetApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const statefulSetApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "statefulSetApi is only available in certain environments");
return new StatefulSetApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { StorageClassApi } from "./storage-class.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const storageClassApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const storageClassApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "storageClassApi is only available in certain environments");
return new StorageClassApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -6,7 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
import { ValidatingWebhookConfigurationApi } from "./validating-webhook-configuration.api";
@ -16,7 +16,7 @@ const validatingWebhookConfigurationApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "validatingWebhookApi is only available in certain environments");
return new ValidatingWebhookConfigurationApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { VerticalPodAutoscalerApi } from "./vertical-pod-autoscaler.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const verticalPodAutoscalerApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const verticalPodAutoscalerApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "verticalPodAutoscalerApi is only available in certain environments");
return new VerticalPodAutoscalerApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

4
packages/core/src/common/k8s/create-resource-stack.injectable.ts
View File

@ -7,7 +7,7 @@ import type { KubernetesCluster } from "../catalog-entities";
import readDirectoryInjectable from "../fs/read-directory.injectable";
import readFileInjectable from "../fs/read-file.injectable";
import { kubectlApplyAllInjectionToken, kubectlDeleteAllInjectionToken } from "../kube-helpers/channels";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import joinPathsInjectable from "../path/join-paths.injectable";
import type { ResourceApplyingStack, ResourceStackDependencies } from "./resource-stack";
import { ResourceStack } from "./resource-stack";
@ -21,7 +21,7 @@ const createResourceStackInjectable = getInjectable({
joinPaths: di.inject(joinPathsInjectable),
kubectlApplyAll: di.inject(kubectlApplyAllInjectionToken),
kubectlDeleteAll: di.inject(kubectlDeleteAllInjectionToken),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
readDirectory: di.inject(readDirectoryInjectable),
readFile: di.inject(readFileInjectable),
};

4
packages/core/src/common/log-error.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 { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
const logErrorInjectable = getInjectable({
id: "log-error",
instantiate: (di) => di.inject(loggerInjectable).error,
instantiate: (di) => di.inject(loggerInjectionToken).error,
decorable: false,
});

4
packages/core/src/common/logger.global-override-for-injectable.ts
View File

@ -3,10 +3,10 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import { getGlobalOverride } from "@k8slens/test-utils";
export default getGlobalOverride(loggerInjectable, () => ({
export default getGlobalOverride(loggerInjectionToken, () => ({
warn: () => {},
debug: () => {},
error: () => {},

4
packages/core/src/common/persistent-storage/create.injectable.ts
View File

@ -10,7 +10,7 @@ import type { IEqualsComparer } from "mobx";
import { reaction } from "mobx";
import directoryForUserDataInjectable from "../app-paths/directory-for-user-data/directory-for-user-data.injectable";
import getConfigurationFileModelInjectable from "../get-configuration-file-model/get-configuration-file-model.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import getBasenameOfPathInjectable from "../path/get-basename.injectable";
import { enlistMessageChannelListenerInjectionToken, sendMessageToChannelInjectionToken } from "@k8slens/messaging";
import type { MessageChannel } from "@k8slens/messaging";
@ -63,7 +63,7 @@ const createPersistentStorageInjectable = getInjectable({
instantiate: (di): CreatePersistentStorage => {
const directoryForUserData = di.inject(directoryForUserDataInjectable);
const getConfigurationFileModel = di.inject(getConfigurationFileModelInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
const getBasenameOfPath = di.inject(getBasenameOfPathInjectable);
const ipcChannelPrefixes = di.inject(persistentStorageIpcChannelPrefixesInjectionToken);
const persistStateToConfig = di.inject(persistStateToConfigInjectionToken);

4
packages/core/src/common/persistent-storage/migrations.injectable.ts
View File

@ -4,7 +4,7 @@
*/
import type { InjectionToken } from "@ogre-tools/injectable";
import { lifecycleEnum, getInjectable } from "@ogre-tools/injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import { getOrInsert, iter, object } from "@k8slens/utilities";
export type AllowedSetValue<T> = T extends (...args: any[]) => any
@ -32,7 +32,7 @@ export interface MigrationDeclaration {
const persistentStorageMigrationsInjectable = getInjectable({
id: "persistent-storage-migrations",
instantiate: (di, token) => {
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
const declarations = di.injectMany(token);
const migrations = new Map<string, MigrationDeclaration["run"][]>();

42
packages/core/src/extensions/as-legacy-globals-for-extension-api/as-legacy-global-singleton-object-for-extension-api.ts Normal file
View File

@ -0,0 +1,42 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import type { Injectable } from "@ogre-tools/injectable";
import { asLegacyGlobalForExtensionApi } from "./as-legacy-global-object-for-extension-api";
import { getLegacyGlobalDiForExtensionApi } from "./legacy-global-di-for-extension-api";
import { loggerInjectable } from "@k8slens/logger";
export interface LegacySingleton<T> {
createInstance(): T;
getInstance(): T;
resetInstance(): void;
}
export function asLegacyGlobalSingletonForExtensionApi<Instance>(injectable: Injectable<Instance, unknown, void>): LegacySingleton<Instance>;
export function asLegacyGlobalSingletonForExtensionApi<Instance, InstantiationParameter>(injectable: Injectable<Instance, unknown, InstantiationParameter>, param: InstantiationParameter): LegacySingleton<Instance>;
export function asLegacyGlobalSingletonForExtensionApi<Instance, InstantiationParameter>(
injectable: Injectable<Instance, unknown, InstantiationParameter>,
instantiationParameter?: InstantiationParameter,
): LegacySingleton<Instance> {
const instance = asLegacyGlobalForExtensionApi(
injectable as never,
instantiationParameter,
) as Instance;
return {
createInstance: () => instance,
getInstance: () => instance,
resetInstance: () => {
const di = getLegacyGlobalDiForExtensionApi();
const logger = di.inject(loggerInjectable);
logger.warn(
`resetInstance() for a legacy global singleton of "${injectable.id}" does nothing.`,
);
},
};
}

4
packages/core/src/extensions/common-api/index.ts
View File

@ -3,7 +3,7 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import { asLegacyGlobalForExtensionApi } from "@k8slens/legacy-global-di";
// APIs
@ -20,4 +20,4 @@ export type { LensExtension } from "../lens-extension";
export type { PackageJson } from "type-fest";
export type { LensExtensionManifest, InstalledExtension } from "@k8slens/legacy-extensions";
export const logger = asLegacyGlobalForExtensionApi(loggerInjectable);
export const logger = asLegacyGlobalForExtensionApi(loggerInjectionToken);

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

@ -21,7 +21,7 @@ import type { DerivedKubeApiOptions, KubeApiDependencies, KubeApiOptions } from
import { KubeApi as InternalKubeApi } from "../../common/k8s-api/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 { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../../common/k8s-api/maybe-kube-api.injectable";
import { DeploymentApi as InternalDeploymentApi, IngressApi as InternalIngressApi, NodeApi, PersistentVolumeClaimApi, PodApi } from "../../common/k8s-api/endpoints";
import { storesAndApisCanBeCreatedInjectionToken } from "../../common/k8s-api/stores-apis-can-be-created.token";
@ -42,7 +42,7 @@ const getKubeApiDeps = (): KubeApiDependencies => {
const di = getLegacyGlobalDiForExtensionApi();
return {
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
};
};
@ -190,7 +190,7 @@ export abstract class KubeObjectStore<
super(
{
context: di.inject(clusterFrameContextForNamespacedResourcesInjectable),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
},
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
api!,

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

@ -10,7 +10,7 @@ import extensionInstallationStateStoreInjectable from "../extension-installation
import installExtensionInjectable from "../install-extension/install-extension.injectable";
import extensionPackageRootDirectoryInjectable from "../install-extension/extension-package-root-directory.injectable";
import readJsonFileInjectable from "../../common/fs/read-json-file.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import pathExistsInjectable from "../../common/fs/path-exists.injectable";
import watchInjectable from "../../common/fs/watch/watch.injectable";
import accessPathInjectable from "../../common/fs/access-path.injectable";
@ -43,7 +43,7 @@ const extensionDiscoveryInjectable = getInjectable({
readJsonFile: di.inject(readJsonFileInjectable),
pathExists: di.inject(pathExistsInjectable),
watch: di.inject(watchInjectable),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
accessPath: di.inject(accessPathInjectable),
copy: di.inject(copyInjectable),
removePath: di.inject(removePathInjectable),

4
packages/core/src/extensions/extension-installation-state-store/extension-installation-state-store.injectable.ts
View File

@ -3,13 +3,13 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import { ExtensionInstallationStateStore } from "./extension-installation-state-store";
const extensionInstallationStateStoreInjectable = getInjectable({
id: "extension-installation-state-store",
instantiate: (di) => new ExtensionInstallationStateStore({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
}),
});

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

@ -6,7 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
import { ExtensionLoader } from "./extension-loader";
import extensionInstancesInjectable from "./extension-instances.injectable";
import extensionInjectable from "./extension/extension.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import joinPathsInjectable from "../../common/path/join-paths.injectable";
import getDirnameOfPathInjectable from "../../common/path/get-dirname.injectable";
import { bundledExtensionInjectionToken } from "@k8slens/legacy-extensions";
@ -22,7 +22,7 @@ const extensionLoaderInjectable = getInjectable({
getExtension: (instance) => di.inject(extensionInjectable, instance),
bundledExtensions: di.injectMany(bundledExtensionInjectionToken),
extensionEntryPointName: di.inject(extensionEntryPointNameInjectionToken),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
joinPaths: di.inject(joinPathsInjectable),
getDirnameOfPath: di.inject(getDirnameOfPathInjectable),
}),

4
packages/core/src/extensions/ipc/ipc-main.ts
View File

@ -11,7 +11,7 @@ import { once } from "lodash";
import { ipcMainHandle } from "../../common/ipc";
import type { Logger } from "@k8slens/logger";
import { getEnvironmentSpecificLegacyGlobalDiForExtensionApi } from "@k8slens/legacy-global-di";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
interface Dependencies {
readonly logger: Logger;
@ -26,7 +26,7 @@ export abstract class IpcMain extends IpcRegistrar {
const di = getEnvironmentSpecificLegacyGlobalDiForExtensionApi("main");
this.dependencies = {
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
};
// Call the static method on the bottom child class.

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

@ -16,7 +16,7 @@ import type { InstalledExtension } from "./common-api";
import type { CatalogEntityRegistry } from "../main/catalog";
import type { NavigateForExtension } from "../main/start-main-application/lens-window/navigate-for-extension.injectable";
import catalogEntityRegistryInjectable from "../main/catalog/entity-registry.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import navigateForExtensionInjectable from "../main/start-main-application/lens-window/navigate-for-extension.injectable";
import ensureHashedDirectoryForExtensionInjectable from "./extension-loader/file-system-provisioner-store/ensure-hashed-directory-for-extension.injectable";
@ -40,7 +40,7 @@ export class LensMainExtension extends LensExtension {
ensureHashedDirectoryForExtension: di.inject(ensureHashedDirectoryForExtensionInjectable),
navigate: di.inject(navigateForExtensionInjectable),
entityRegistry: di.inject(catalogEntityRegistryInjectable),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
};
super(deps, extension);

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

@ -39,7 +39,7 @@ import type { InstalledExtension } from "./common-api";
import { getEnvironmentSpecificLegacyGlobalDiForExtensionApi } from "@k8slens/legacy-global-di";
import catalogCategoryRegistryInjectable from "../common/catalog/category-registry.injectable";
import catalogEntityRegistryInjectable from "../renderer/api/catalog/entity/registry.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import getExtensionPageParametersInjectable from "../renderer/routes/get-extension-page-parameters.injectable";
import navigateToRouteInjectable from "../renderer/routes/navigate-to-route.injectable";
import routesInjectable from "../renderer/routes/routes.injectable";
@ -89,7 +89,7 @@ export class LensRendererExtension extends LensExtension {
categoryRegistry: di.inject(catalogCategoryRegistryInjectable),
entityRegistry: di.inject(catalogEntityRegistryInjectable),
routes: di.inject(routesInjectable),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
};
super(deps, extension);

4
packages/core/src/features/application-menu/main/menu-items/help/open-documentation/open-documentation-menu-item.injectable.ts
View File

@ -6,14 +6,14 @@ import { getInjectable } from "@ogre-tools/injectable";
import applicationMenuItemInjectionToken from "../../application-menu-item-injection-token";
import { docsUrl } from "../../../../../../common/vars";
import openLinkInBrowserInjectable from "../../../../../../common/utils/open-link-in-browser.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
const openDocumentationMenuItemInjectable = getInjectable({
id: "open-documentation-menu-item",
instantiate: (di) => {
const openLinkInBrowser = di.inject(openLinkInBrowserInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return {
kind: "clickable-menu-item" as const,

4
packages/core/src/features/application-menu/main/menu-items/help/open-support/open-support-item.injectable.ts
View File

@ -6,14 +6,14 @@ import { getInjectable } from "@ogre-tools/injectable";
import applicationMenuItemInjectionToken from "../../application-menu-item-injection-token";
import { supportUrl } from "../../../../../../common/vars";
import openLinkInBrowserInjectable from "../../../../../../common/utils/open-link-in-browser.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
const openSupportItemInjectable = getInjectable({
id: "open-support-menu-item",
instantiate: (di) => {
const openLinkInBrowser = di.inject(openLinkInBrowserInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return {
kind: "clickable-menu-item" as const,

4
packages/core/src/features/application-update/main/check-for-updates/check-for-platform-updates/check-for-platform-updates.injectable.ts
View File

@ -5,7 +5,7 @@
import { getInjectable } from "@ogre-tools/injectable";
import electronUpdaterInjectable from "../../../../../main/electron-app/features/electron-updater.injectable";
import type { UpdateChannel } from "../../../common/update-channels";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import type { UpdateCheckResult } from "electron-updater";
export type CheckForUpdatesResult = {
@ -22,7 +22,7 @@ const checkForPlatformUpdatesInjectable = getInjectable({
instantiate: (di): CheckForPlatformUpdates => {
const electronUpdater = di.inject(electronUpdaterInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return async (updateChannel, { allowDowngrade }) => {
electronUpdater.channel = updateChannel.id;

4
packages/core/src/features/application-update/main/check-for-updates/check-for-platform-updates/check-for-platform-updates.test.ts
View File

@ -11,7 +11,7 @@ import type { CheckForPlatformUpdates } from "./check-for-platform-updates.injec
import checkForPlatformUpdatesInjectable from "./check-for-platform-updates.injectable";
import type { UpdateChannel, ReleaseChannel } from "../../../common/update-channels";
import { getPromiseStatus } from "@k8slens/test-utils";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import { noop } from "@k8slens/utilities";
describe("check-for-platform-updates", () => {
@ -39,7 +39,7 @@ describe("check-for-platform-updates", () => {
logErrorMock = jest.fn();
di.override(loggerInjectable, () => ({
di.override(loggerInjectionToken, () => ({
error: logErrorMock,
debug: noop,
info: noop,

4
packages/core/src/features/application-update/main/download-update/download-platform-update/download-platform-update.injectable.ts
View File

@ -4,7 +4,7 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import electronUpdaterInjectable from "../../../../../main/electron-app/features/electron-updater.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import type { ProgressInfo } from "electron-updater";
import type { ProgressOfDownload } from "../../../common/progress-of-update-download.injectable";
@ -17,7 +17,7 @@ const downloadPlatformUpdateInjectable = getInjectable({
instantiate: (di): DownloadPlatformUpdate => {
const electronUpdater = di.inject(electronUpdaterInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return async (onDownloadProgress) => {
onDownloadProgress({ percentage: 0 });

4
packages/core/src/features/application-update/main/download-update/download-platform-update/download-platform-update.test.ts
View File

@ -11,7 +11,7 @@ import type { AsyncFnMock } from "@async-fn/jest";
import asyncFn from "@async-fn/jest";
import { getPromiseStatus } from "@k8slens/test-utils";
import type { DiContainer } from "@ogre-tools/injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import { noop } from "@k8slens/utilities";
describe("download-platform-update", () => {
@ -45,7 +45,7 @@ describe("download-platform-update", () => {
di.override(electronUpdaterInjectable, () => electronUpdaterFake);
logErrorMock = jest.fn();
di.override(loggerInjectable, () => ({
di.override(loggerInjectionToken, () => ({
error: logErrorMock,
debug: noop,
info: noop,

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

@ -4,7 +4,7 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import execFileInjectable from "../../../common/fs/exec-file.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import type { AsyncResult } from "@k8slens/utilities";
import { platformSpecificRequestSystemCAsInjectionToken } from "../common/request-system-cas-token";
@ -17,7 +17,7 @@ const darwinRequestSystemCAsInjectable = getInjectable({
platform: "darwin" as const,
instantiate: () => {
const execFile = di.inject(execFileInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
const execSecurity = async (...args: string[]): AsyncResult<string[]> => {
const result = await execFile("/usr/bin/security", args);

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

@ -4,7 +4,7 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import execFileInjectable from "../../../common/fs/exec-file.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import { platformSpecificRequestSystemCAsInjectionToken } from "../common/request-system-cas-token";
const pemEncoding = (hexEncodedCert: String) => {
@ -27,7 +27,7 @@ const win32RequestSystemCAsInjectable = getInjectable({
instantiate: () => {
const winCARootsExePath: string = __non_webpack_require__.resolve("win-ca/lib/roots.exe");
const execFile = di.inject(execFileInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return async () => {
/**

4
packages/core/src/features/cluster/storage/common/storage.injectable.ts
View File

@ -8,7 +8,7 @@ import { comparer, action } from "mobx";
import { clusterStoreMigrationInjectionToken } from "./migration-token";
import type { ClusterId, ClusterModel } from "../../../../common/cluster-types";
import { Cluster } from "../../../../common/cluster/cluster";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import createPersistentStorageInjectable from "../../../../common/persistent-storage/create.injectable";
import persistentStorageMigrationsInjectable from "../../../../common/persistent-storage/migrations.injectable";
import storeMigrationVersionInjectable from "../../../../common/vars/store-migration-version.injectable";
@ -23,7 +23,7 @@ const clustersPersistentStorageInjectable = getInjectable({
instantiate: (di) => {
const createPersistentStorage = di.inject(createPersistentStorageInjectable);
const clustersState = di.inject(clustersStateInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return createPersistentStorage<ClusterStoreModel>({
configName: "lens-cluster-store",

4
packages/core/src/features/helm-charts/child-features/preferences/renderer/adding-of-public-helm-repository/public-helm-repositories/request-public-helm-repositories.injectable.ts
View File

@ -7,7 +7,7 @@ import { sortBy } from "lodash/fp";
import proxyDownloadJsonInjectable from "../../../../../../../common/fetch/download-json/proxy.injectable";
import { withTimeout } from "../../../../../../../common/fetch/timeout-controller";
import type { HelmRepo } from "../../../../../../../common/helm/helm-repo";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
const publicHelmReposUrl = "https://github.com/lensapp/artifact-hub-repositories/releases/download/latest/repositories.json";
@ -16,7 +16,7 @@ const requestPublicHelmRepositoriesInjectable = getInjectable({
instantiate: (di) => {
const downloadJson = di.inject(proxyDownloadJsonInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return async (): Promise<HelmRepo[]> => {
const controller = withTimeout(10_000);

4
packages/core/src/features/helm-charts/listing-active-helm-repositories-in-preferences.test.ts
View File

@ -12,7 +12,7 @@ import asyncFn from "@async-fn/jest";
import type { HelmRepositoriesFromYaml } from "../../main/helm/repositories/get-active-helm-repositories/get-active-helm-repositories.injectable";
import execFileInjectable, { type ExecFile } from "../../common/fs/exec-file.injectable";
import helmBinaryPathInjectable from "../../main/helm/helm-binary-path.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import type { Logger } from "@k8slens/logger";
import requestPublicHelmRepositoriesInjectable from "./child-features/preferences/renderer/adding-of-public-helm-repository/public-helm-repositories/request-public-helm-repositories.injectable";
import showErrorNotificationInjectable from "../../renderer/components/notifications/show-error-notification.injectable";
@ -45,7 +45,7 @@ describe("listing active helm repositories in preferences", () => {
mainDi.override(readYamlFileInjectable, () => readYamlFileMock);
mainDi.override(execFileInjectable, () => execFileMock);
mainDi.override(helmBinaryPathInjectable, () => "some-helm-binary-path");
mainDi.override(loggerInjectable, () => loggerStub);
mainDi.override(loggerInjectionToken, () => loggerStub);
});
builder.beforeWindowStart(({ windowDi }) => {

4
packages/core/src/features/hotbar/storage/main/5.0.0-beta.10.injectable.ts
View File

@ -11,7 +11,7 @@ import joinPathsInjectable from "../../../../common/path/join-paths.injectable";
import { getInjectable } from "@ogre-tools/injectable";
import { hotbarStoreMigrationInjectionToken } from "../common/migrations-token";
import readJsonSyncInjectable from "../../../../common/fs/read-json-sync.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import { generateNewIdFor } from "../../../../common/utils/generate-new-id-for";
import type { ClusterModel } from "../../../../common/cluster-types";
import { defaultHotbarCells } from "../common/types";
@ -43,7 +43,7 @@ const v500Beta10HotbarStoreMigrationInjectable = getInjectable({
const joinPaths = di.inject(joinPathsInjectable);
const readJsonSync = di.inject(readJsonSyncInjectable);
const catalogCatalogEntity = di.inject(catalogCatalogEntityInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
const createHotbar = di.inject(createHotbarInjectable);
const rawHotbars = store.get("hotbars");
const hotbars: HotbarData[] = Array.isArray(rawHotbars) ? rawHotbars.filter(h => h && typeof h === "object") : [];

4
packages/core/src/features/hotbar/storage/storage-technical.test.ts
View File

@ -12,7 +12,7 @@ import type { IComputedValue } from "mobx";
import { computed } from "mobx";
import hasCategoryForEntityInjectable from "../../../common/catalog/has-category-for-entity.injectable";
import catalogCatalogEntityInjectable from "../../../common/catalog-entities/general-catalog-entities/implementations/catalog-catalog-entity.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import type { Logger } from "@k8slens/logger";
import directoryForUserDataInjectable from "../../../common/app-paths/directory-for-user-data/directory-for-user-data.injectable";
import storeMigrationVersionInjectable from "../../../common/vars/store-migration-version.injectable";
@ -109,7 +109,7 @@ describe("Hotbars technical tests", () => {
silly: jest.fn(),
};
di.override(loggerInjectable, () => loggerMock);
di.override(loggerInjectionToken, () => loggerMock);
di.override(directoryForUserDataInjectable, () => "/some-directory-for-user-data");

4
packages/core/src/features/preferences/renderer/preference-items/kubernetes/kubeconfig-sync/discover-sync-kind.injectable.ts
View File

@ -4,7 +4,7 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import statInjectable from "../../../../../../common/fs/stat.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
export interface SyncKind {
type: "file" | "folder" | "unknown";
@ -16,7 +16,7 @@ const discoverKubeconfigSyncKindInjectable = getInjectable({
id: "discover-kubeconfig-sync-kind",
instantiate: (di): DiscoverKubeconfigSyncKind => {
const stat = di.inject(statInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return async (path) => {
try {

4
packages/core/src/features/preferences/renderer/preference-items/kubernetes/kubeconfig-sync/kubeconfig-sync.tsx
View File

@ -13,7 +13,7 @@ import { PathPicker } from "../../../../../../renderer/components/path-picker/pa
import { Spinner } from "../../../../../../renderer/components/spinner";
import { RemovableItem } from "../../../removable-item/removable-item";
import isWindowsInjectable from "../../../../../../common/vars/is-windows.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import type { Logger } from "@k8slens/logger";
import type { DiscoverAllKubeconfigSyncKinds } from "./discover-all-sync-kinds.injectable";
import type { DiscoverKubeconfigSyncKind, SyncKind } from "./discover-sync-kind.injectable";
@ -179,7 +179,7 @@ export const KubeconfigSync = withInjectables<Dependencies>(NonInjectedKubeconfi
getProps: (di) => ({
state: di.inject(userPreferencesStateInjectable),
isWindows: di.inject(isWindowsInjectable),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
discoverAllKubeconfigSyncKinds: di.inject(discoverAllKubeconfigSyncKindsInjectable),
discoverKubeconfigSyncKind: di.inject(discoverKubeconfigSyncKindInjectable),
}),

4
packages/core/src/features/shell-sync/main/compute-unix-shell-environment.injectable.ts
View File

@ -7,7 +7,7 @@ import { getInjectable } from "@ogre-tools/injectable";
import getBasenameOfPathInjectable from "../../../common/path/get-basename.injectable";
import spawnInjectable from "../../../main/child-process/spawn.injectable";
import randomUUIDInjectable from "../../../main/crypto/random-uuid.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import processExecPathInjectable from "./execPath.injectable";
import processEnvInjectable from "./env.injectable";
import { object } from "@k8slens/utilities";
@ -56,7 +56,7 @@ const computeUnixShellEnvironmentInjectable = getInjectable({
const getBasenameOfPath = di.inject(getBasenameOfPathInjectable);
const spawn = di.inject(spawnInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
const randomUUID = di.inject(randomUUIDInjectable);
const processExecPath = di.inject(processExecPathInjectable);
const processEnv = di.inject(processEnvInjectable);

4
packages/core/src/features/shell-sync/main/setup-shell.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 { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import { onLoadOfApplicationInjectionToken } from "@k8slens/application";
import isSnapPackageInjectable from "../../../common/vars/is-snap-package.injectable";
import electronAppInjectable from "../../../main/electron-app/electron-app.injectable";
@ -17,7 +17,7 @@ const setupShellInjectable = getInjectable({
instantiate: (di) => ({
run: async () => {
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
const isSnapPackage = di.inject(isSnapPackageInjectable);
const electronApp = di.inject(electronAppInjectable);
const resolvedUserShellSetting = di.inject(userShellSettingInjectable);

4
packages/core/src/features/user-preferences/main/5.0.3-beta.1.injectable.ts
View File

@ -13,7 +13,7 @@ import { getInjectable } from "@ogre-tools/injectable";
import { userPreferencesMigrationInjectionToken } from "../../../features/user-preferences/common/migrations-token";
import readJsonSyncInjectable from "../../../common/fs/read-json-sync.injectable";
import homeDirectoryPathInjectable from "../../../common/os/home-directory-path.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import pathExistsSyncInjectable from "../../../common/fs/path-exists-sync.injectable";
import type { ClusterStoreModel } from "../../../features/cluster/storage/common/storage.injectable";
import type { UserPreferencesModel, KubeconfigSyncEntry } from "../common/preferences-helpers";
@ -24,7 +24,7 @@ const v503Beta1UserPreferencesStorageMigrationInjectable = getInjectable({
const userDataPath = di.inject(directoryForUserDataInjectable);
const kubeConfigsPath = di.inject(directoryForKubeConfigsInjectable);
const joinPaths = di.inject(joinPathsInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
const isLogicalChildPath = di.inject(isLogicalChildPathInjectable);
const getDirnameOfPath = di.inject(getDirnameOfPathInjectable);
const readJsonSync = di.inject(readJsonSyncInjectable);

4
packages/core/src/main/__test__/kubeconfig-manager.test.ts
View File

@ -8,7 +8,7 @@ import { Cluster } from "../../common/cluster/cluster";
import kubeconfigManagerInjectable from "../kubeconfig-manager/kubeconfig-manager.injectable";
import directoryForTempInjectable from "../../common/app-paths/directory-for-temp/directory-for-temp.injectable";
import type { DiContainer } from "@ogre-tools/injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import type { Logger } from "@k8slens/logger";
import directoryForUserDataInjectable from "../../common/app-paths/directory-for-user-data/directory-for-user-data.injectable";
import normalizedPlatformInjectable from "../../common/vars/normalized-platform.injectable";
@ -73,7 +73,7 @@ describe("kubeconfig manager tests", () => {
silly: jest.fn(),
};
di.override(loggerInjectable, () => loggerMock);
di.override(loggerInjectionToken, () => loggerMock);
ensureServerMock = asyncFn();

4
packages/core/src/main/base-store/persist-state-to-config.injectable.ts
View File

@ -4,12 +4,12 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import { persistStateToConfigInjectionToken } from "../../common/persistent-storage/save-to-file";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
const persistStateToConfigInjectable = getInjectable({
id: "persist-state-to-config",
instantiate: (di) => {
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return (config, state) => {
logger.info(`[BASE-STORE]: saving ${config.path}...`);

4
packages/core/src/main/cluster/broadcast-connection-update.injectable.ts
View File

@ -6,7 +6,7 @@ import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
import type { KubeAuthUpdate } from "../../common/cluster-types";
import type { Cluster } from "../../common/cluster/cluster";
import broadcastMessageInjectable from "../../common/ipc/broadcast-message.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
export type BroadcastConnectionUpdate = (update: KubeAuthUpdate) => void;
@ -14,7 +14,7 @@ const broadcastConnectionUpdateInjectable = getInjectable({
id: "broadcast-connection-update",
instantiate: (di, cluster): BroadcastConnectionUpdate => {
const broadcastMessage = di.inject(broadcastMessageInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return (update) => {
logger.debug(`[CLUSTER]: broadcasting connection update`, { ...update, meta: cluster.getMeta() });

4
packages/core/src/main/cluster/cluster-connection.injectable.ts
View File

@ -25,7 +25,7 @@ import broadcastMessageInjectable from "../../common/ipc/broadcast-message.injec
import createListNamespacesInjectable from "../../common/cluster/list-namespaces.injectable";
import kubeAuthProxyServerInjectable from "./kube-auth-proxy-server.injectable";
import loadProxyKubeconfigInjectable from "./load-proxy-kubeconfig.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import prometheusHandlerInjectable from "./prometheus-handler/prometheus-handler.injectable";
import removeProxyKubeconfigInjectable from "./remove-proxy-kubeconfig.injectable";
import requestApiResourcesInjectable from "./request-api-resources.injectable";
@ -407,7 +407,7 @@ const clusterConnectionInjectable = getInjectable({
{
clusterVersionDetector: di.inject(clusterVersionDetectorInjectable),
kubeAuthProxyServer: di.inject(kubeAuthProxyServerInjectable, cluster),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
prometheusHandler: di.inject(prometheusHandlerInjectable, cluster),
broadcastConnectionUpdate: di.inject(broadcastConnectionUpdateInjectable, cluster),
broadcastMessage: di.inject(broadcastMessageInjectable),

4
packages/core/src/main/cluster/manager.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 { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import addClusterInjectable from "../../features/cluster/storage/common/add.injectable";
import clustersInjectable from "../../features/cluster/storage/common/clusters.injectable";
import getClusterByIdInjectable from "../../features/cluster/storage/common/get-by-id.injectable";
@ -22,7 +22,7 @@ const clusterManagerInjectable = getInjectable({
catalogEntityRegistry: di.inject(catalogEntityRegistryInjectable),
clustersThatAreBeingDeleted: di.inject(clustersThatAreBeingDeletedInjectable),
visibleCluster: di.inject(visibleClusterInjectable),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
addCluster: di.inject(addClusterInjectable),
clusters: di.inject(clustersInjectable),
getClusterById: di.inject(getClusterByIdInjectable),

4
packages/core/src/main/cluster/prometheus-handler/prometheus-handler.injectable.ts
View File

@ -7,7 +7,7 @@ import type { Cluster } from "../../../common/cluster/cluster";
import { createClusterPrometheusHandler } from "./prometheus-handler";
import getPrometheusProviderByKindInjectable from "../../prometheus/get-by-kind.injectable";
import prometheusProvidersInjectable from "../../prometheus/providers.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import loadProxyKubeconfigInjectable from "../load-proxy-kubeconfig.injectable";
const prometheusHandlerInjectable = getInjectable({
@ -17,7 +17,7 @@ const prometheusHandlerInjectable = getInjectable({
{
getPrometheusProviderByKind: di.inject(getPrometheusProviderByKindInjectable),
prometheusProviders: di.inject(prometheusProvidersInjectable),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
loadProxyKubeconfig: di.inject(loadProxyKubeconfigInjectable, cluster),
},
cluster,

4
packages/core/src/main/cluster/request-api-resources.injectable.ts
View File

@ -4,7 +4,7 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import type { KubeApiResource } from "../../common/rbac";
import type { Cluster } from "../../common/cluster/cluster";
import { apiVersionsRequesterInjectionToken } from "./api-versions-requester";
@ -24,7 +24,7 @@ export interface KubeResourceListGroup {
const requestApiResourcesInjectable = getInjectable({
id: "request-api-resources",
instantiate: (di): RequestApiResources => {
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
const apiVersionRequesters = di.injectMany(apiVersionsRequesterInjectionToken)
.sort(byOrderNumber);
const requestKubeApiResourcesFor = di.inject(requestKubeApiResourcesForInjectable);

4
packages/core/src/main/cluster/store-migrations/3.6.0-beta.1.injectable.ts
View File

@ -20,7 +20,7 @@ interface Pre360ClusterModel extends ClusterModel {
import { getInjectable } from "@ogre-tools/injectable";
import { clusterStoreMigrationInjectionToken } from "../../../features/cluster/storage/common/migration-token";
import readFileBufferSyncInjectable from "../../../common/fs/read-file-buffer-sync.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import writeFileSyncInjectable from "../../../common/fs/write-file-sync.injectable";
const v360Beta1ClusterStoreMigrationInjectable = getInjectable({
@ -31,7 +31,7 @@ const v360Beta1ClusterStoreMigrationInjectable = getInjectable({
const readFileSync = di.inject(readFileSyncInjectable);
const readFileBufferSync = di.inject(readFileBufferSyncInjectable);
const joinPaths = di.inject(joinPathsInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
const writeFileSync = di.inject(writeFileSyncInjectable);
return {

4
packages/core/src/main/cluster/store-migrations/5.0.0-beta.13.injectable.ts
View File

@ -9,7 +9,7 @@ import directoryForUserDataInjectable from "../../../common/app-paths/directory-
import { isDefined } from "@k8slens/utilities";
import joinPathsInjectable from "../../../common/path/join-paths.injectable";
import { getInjectable } from "@ogre-tools/injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import { clusterStoreMigrationInjectionToken } from "../../../features/cluster/storage/common/migration-token";
import { generateNewIdFor } from "../../../common/utils/generate-new-id-for";
@ -77,7 +77,7 @@ const v500Beta13ClusterStoreMigrationInjectable = getInjectable({
instantiate: (di) => {
const userDataPath = di.inject(directoryForUserDataInjectable);
const joinPaths = di.inject(joinPathsInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
const moveStorageFolder = ({ folder, newId, oldId }: { folder: string; newId: string; oldId: string }): void => {
const oldPath = joinPaths(folder, `${oldId}.json`);

4
packages/core/src/main/cluster/store-migrations/snap.injectable.ts
View File

@ -7,7 +7,7 @@
import { getInjectable } from "@ogre-tools/injectable";
import { clusterStoreMigrationInjectionToken } from "../../../features/cluster/storage/common/migration-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import isSnapPackageInjectable from "../../../common/vars/is-snap-package.injectable";
import type { ClusterModel } from "../../../common/cluster-types";
import pathExistsSyncInjectable from "../../../common/fs/path-exists-sync.injectable";
@ -17,7 +17,7 @@ const clusterStoreSnapMigrationInjectable = getInjectable({
id: "cluster-store-snap-migration",
instantiate: (di) => {
const { version } = di.inject(applicationInformationToken);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
const isSnapPackage = di.inject(isSnapPackageInjectable);
const pathExistsSync = di.inject(pathExistsSyncInjectable);

4
packages/core/src/main/electron-app/runnables/setup-deep-linking.injectable.ts
View File

@ -5,7 +5,7 @@
import { getInjectable } from "@ogre-tools/injectable";
import electronAppInjectable from "../electron-app.injectable";
import openDeepLinkInjectable from "../../protocol-handler/lens-protocol-router-main/open-deep-link-for-url/open-deep-link.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import commandLineArgumentsInjectable from "../../utils/command-line-arguments.injectable";
import { startsWith, toLower } from "lodash/fp";
import { onLoadOfApplicationInjectionToken } from "@k8slens/application";
@ -17,7 +17,7 @@ const setupDeepLinkingInjectable = getInjectable({
instantiate: (di) => ({
run: async () => {
const app = di.inject(electronAppInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
const openDeepLinkForUrl = di.inject(openDeepLinkInjectable);
const showApplicationWindow = di.inject(showApplicationWindowInjectable);
const firstInstanceCommandLineArguments = di.inject(commandLineArgumentsInjectable);

4
packages/core/src/main/electron-app/runnables/setup-developer-tools-in-development-environment.injectable.ts
View File

@ -4,7 +4,7 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import { nodeEnvInjectionToken } from "../../../common/vars/node-env-injection-token";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import { onLoadOfApplicationInjectionToken } from "@k8slens/application";
const setupDeveloperToolsInDevelopmentEnvironmentInjectable = getInjectable({
@ -12,7 +12,7 @@ const setupDeveloperToolsInDevelopmentEnvironmentInjectable = getInjectable({
instantiate: (di) => ({
run: () => {
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
const nodeEnv = di.inject(nodeEnvInjectionToken);
if (nodeEnv !== "development") {

4
packages/core/src/main/electron-app/runnables/setup-ipc-main-handlers/setup-ipc-main-handlers.injectable.ts
View File

@ -4,7 +4,7 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import { setupIpcMainHandlers } from "./setup-ipc-main-handlers";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import { onLoadOfApplicationInjectionToken } from "@k8slens/application";
import applicationMenuItemCompositeInjectable from "../../../../features/application-menu/main/application-menu-item-composite.injectable";
import pushCatalogToRendererInjectable from "../../../catalog-sync-to-renderer/push-catalog-to-renderer.injectable";
@ -17,7 +17,7 @@ const setupIpcMainHandlersInjectable = getInjectable({
instantiate: (di) => ({
run: () => {
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
logger.debug("[APP-MAIN] initializing ipc main handlers");

4
packages/core/src/main/electron-app/runnables/setup-main-window-visibility-after-activation.injectable.ts
View File

@ -4,7 +4,7 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import electronAppInjectable from "../electron-app.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import { onLoadOfApplicationInjectionToken } from "@k8slens/application";
import showApplicationWindowInjectable from "../../start-main-application/lens-window/show-application-window.injectable";
@ -15,7 +15,7 @@ const setupMainWindowVisibilityAfterActivationInjectable = getInjectable({
run: () => {
const app = di.inject(electronAppInjectable);
const showApplicationWindow = di.inject(showApplicationWindowInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
app.on("activate", (_, windowIsVisible) => {
logger.info("APP:ACTIVATE", { hasVisibleWindows: windowIsVisible });

4
packages/core/src/main/helm/helm-chart-manager.injectable.ts
View File

@ -6,7 +6,7 @@ import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
import type { HelmRepo } from "../../common/helm/helm-repo";
import { HelmChartManager } from "./helm-chart-manager";
import helmChartManagerCacheInjectable from "./helm-chart-manager-cache.injectable";
import { loggerInjectable } from "@k8slens/logger";
import { loggerInjectionToken } from "@k8slens/logger";
import execHelmInjectable from "./exec-helm/exec-helm.injectable";
import readFileInjectable from "../../common/fs/read-file.injectable";
import statInjectable from "../../common/fs/stat.injectable";
@ -16,7 +16,7 @@ const helmChartManagerInjectable = getInjectable({
instantiate: (di, repo: HelmRepo) => new HelmChartManager({
cache: di.inject(helmChartManagerCacheInjectable),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
execHelm: di.inject(execHelmInjectable),
readFile: di.inject(readFileInjectable),
stat: di.inject(statInjectable),

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