Fix ordering issues on Runnable token

Signed-off-by: Sebastian Malton <sebastian@malton.name>

src/features/cluster/store/main/init.injectable.ts

@@ -6,20 +6,22 @@ import { getInjectable } from "@ogre-tools/injectable";
 import clusterStoreInjectable from "../../../../common/cluster-store/cluster-store.injectable";
 import { beforeApplicationIsLoadingInjectionToken } from "../../../../main/start-main-application/runnable-tokens/before-application-is-loading-injection-token";
 import initUserStoreInjectable from "../../../../main/stores/init-user-store.injectable";
+import initAuthHeaderStateInjectable from "../../../auth-header/main/init-state.injectable";
 
 const initClusterStoreInjectable = getInjectable({
   id: "init-cluster-store",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const clusterStore = di.inject(clusterStoreInjectable);
+    id: "init-cluster-store",
+    run: () => {
+      const clusterStore = di.inject(clusterStoreInjectable);
 
-    return {
+      clusterStore.load();
-      id: "init-cluster-store",
+    },
-      run: () => {
+    runAfter: [
-        clusterStore.load();
+      di.inject(initUserStoreInjectable),
-      },
+      di.inject(initAuthHeaderStateInjectable),
-      runAfter: di.inject(initUserStoreInjectable),
+    ],
-    };
+  }),
-  },
   injectionToken: beforeApplicationIsLoadingInjectionToken,
 });
 

src/main/lens-proxy/handle-proxy-upgrade.injectable.ts

@@ -1,60 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import type { IncomingMessage } from "http";
-import type { Socket } from "net";
-import type { SetRequired } from "type-fest";
-import loggerInjectable from "../../common/logger.injectable";
-import { apiPrefix, apiKubePrefix } from "../../common/vars";
-import authHeaderStateInjectable from "../../features/auth-header/common/header-state.injectable";
-import { lensAuthHeaderName } from "../../features/auth-header/common/vars";
-import getClusterForRequestInjectable from "./get-cluster-for-request.injectable";
-import { kubeApiUpgradeRequest } from "./proxy-functions";
-import shellApiRequestInjectable from "./proxy-functions/shell-api-request.injectable";
-
-const handleProxyUpgradeRequestInjectable = getInjectable({
-  id: "handle-proxy-upgrade-request",
-  instantiate: (di) => {
-    const getClusterForRequest = di.inject(getClusterForRequestInjectable);
-    const shellApiRequest = di.inject(shellApiRequestInjectable);
-    const logger = di.inject(loggerInjectable);
-    const authHeaderValue = `Bearer ${di.inject(authHeaderStateInjectable).get()}`;
-
-    return (req: SetRequired<IncomingMessage, "url" | "method">, socket: Socket, head: Buffer) => {
-      const cluster = getClusterForRequest(req);
-      const url = new URL(req.url, "https://localhost");
-
-      if (url.searchParams.get(lensAuthHeaderName) !== authHeaderValue) {
-        logger.warn(`[LENS-PROXY]: Request from url=${req.url} missing authentication`);
-        socket.destroy();
-
-        return;
-      }
-
-      if (!cluster) {
-        logger.error(`[LENS-PROXY]: Could not find cluster for upgrade request from url=${req.url}`);
-        socket.destroy();
-
-        return;
-      }
-
-      (async () => {
-        try {
-          if (url.pathname === apiPrefix) {
-            await shellApiRequest({ req, socket, cluster, head });
-          } else if (url.pathname.startsWith(`${apiKubePrefix}/`)) {
-            await kubeApiUpgradeRequest({ req, socket, cluster, head });
-          } else {
-            logger.warn(`[LENS-PROXY]: unknown upgrade request, url=${req.url}`);
-          }
-        } catch (error) {
-          logger.error("[LENS-PROXY]: failed to handle proxy upgrade", error);
-        }
-      })();
-    };
-  },
-});
-
-export default handleProxyUpgradeRequestInjectable;

src/main/lens-proxy/lens-proxy.injectable.ts

@@ -10,7 +10,7 @@ import lensProxyCertificateInjectable from "../../common/certificate/lens-proxy-
 import type net from "net";
 import { createServer } from "https";
 import handleLensRequestInjectable from "./handle-lens-request.injectable";
-import routeUpgradeRequestInjectable from "./upgrade-router/router.injectable";
+import routeUpgradeRequestInjectable from "./upgrade-router/route-upgrade-request.injectable";
 
 export interface LensProxy {
   listen: () => Promise<void>;

src/main/stores/init-user-store.injectable.ts

@@ -10,19 +10,17 @@ import initDefaultUpdateChannelInjectable from "../vars/default-update-channel/i
 
 const initUserStoreInjectable = getInjectable({
   id: "init-user-store",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const userStore = di.inject(userStoreInjectable);
+    id: "init-user-store",
-    const userStoreFileNameMigration = di.inject(userStoreFileNameMigrationInjectable);
+    run: async () => {
+      const userStore = di.inject(userStoreInjectable);
+      const userStoreFileNameMigration = di.inject(userStoreFileNameMigrationInjectable);
 
-    return {
+      await userStoreFileNameMigration();
-      id: "init-user-store",
+      userStore.load();
-      run: async () => {
+    },
-        await userStoreFileNameMigration();
+    runAfter: di.inject(initDefaultUpdateChannelInjectable),
-        userStore.load();
+  }),
-      },
-      runAfter: di.inject(initDefaultUpdateChannelInjectable),
-    };
-  },
   injectionToken: beforeApplicationIsLoadingInjectionToken,
 });
 

src/main/vars/build-version/init.injectable.ts

@@ -8,14 +8,14 @@ import buildVersionInjectable from "./build-version.injectable";
 
 const initializeBuildVersionInjectable = getInjectable({
   id: "initialize-build-version",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const buildVersion = di.inject(buildVersionInjectable);
+    id: "initialize-build-version",
+    run: async () => {
+      const buildVersion = di.inject(buildVersionInjectable);
 
-    return {
+      await buildVersion.init();
-      id: "initialize-build-version",
+    },
-      run: () => buildVersion.init(),
+  }),
-    };
-  },
   injectionToken: beforeApplicationIsLoadingInjectionToken,
 });
 

src/main/vars/default-update-channel/init.injectable.ts

@@ -9,15 +9,15 @@ import defaultUpdateChannelInjectable from "../../../features/application-update
 
 const initDefaultUpdateChannelInjectable = getInjectable({
   id: "init-default-update-channel",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const defaultUpdateChannel = di.inject(defaultUpdateChannelInjectable);
+    id: "init-default-update-channel",
+    run: async () => {
+      const defaultUpdateChannel = di.inject(defaultUpdateChannelInjectable);
 
-    return {
+      await defaultUpdateChannel.init();
-      id: "init-default-update-channel",
+    },
-      run: () => defaultUpdateChannel.init(),
+    runAfter: di.inject(initReleaseChannelInjectable),
-      runAfter: di.inject(initReleaseChannelInjectable),
+  }),
-    };
-  },
   injectionToken: beforeApplicationIsLoadingInjectionToken,
 });
 

src/main/vars/release-channel/init.injectable.ts

@@ -9,15 +9,15 @@ import initSemanticBuildVersionInjectable from "../semantic-build-version/init.i
 
 const initReleaseChannelInjectable = getInjectable({
   id: "init-release-channel",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const releaseChannel = di.inject(releaseChannelInjectable);
+    id: "init-release-channel",
+    run: async () => {
+      const releaseChannel = di.inject(releaseChannelInjectable);
 
-    return {
+      await releaseChannel.init();
-      id: "init-release-channel",
+    },
-      run: () => releaseChannel.init(),
+    runAfter: di.inject(initSemanticBuildVersionInjectable),
-      runAfter: di.inject(initSemanticBuildVersionInjectable),
+  }),
-    };
-  },
   injectionToken: beforeApplicationIsLoadingInjectionToken,
 });
 

src/main/vars/semantic-build-version/init.injectable.ts

@@ -9,15 +9,15 @@ import initializeBuildVersionInjectable from "../build-version/init.injectable";
 
 const initSemanticBuildVersionInjectable = getInjectable({
   id: "init-semantic-build-version",
-  instantiate: (di) => {
+  instantiate: (di) => ({
-    const buildSemanticVersion = di.inject(buildSemanticVersionInjectable);
+    id: "init-semantic-build-version",
+    run: async () => {
+      const buildSemanticVersion = di.inject(buildSemanticVersionInjectable);
 
-    return {
+      return buildSemanticVersion.init();
-      id: "init-semantic-build-version",
+    },
-      run: () => buildSemanticVersion.init(),
+    runAfter: di.inject(initializeBuildVersionInjectable),
-      runAfter: di.inject(initializeBuildVersionInjectable),
+  }),
-    };
-  },
   injectionToken: beforeApplicationIsLoadingInjectionToken,
 });