feat: initial Boot/Shutdown options from tray menu

This PR also includes a bit of code cleanup/refactoring, placing the tray logic under a subdirectory.

Author: starpit

package-lock.json

@@ -86,10 +86,10 @@
     "printWidth": 120
   },
   "devDependencies": {
-    "@kui-shell/builder": "11.5.0-dev-20220715-111236",
-    "@kui-shell/proxy": "11.5.0-dev-20220715-111236",
-    "@kui-shell/react": "11.5.0-dev-20220715-111236",
-    "@kui-shell/webpack": "11.5.0-dev-20220715-111236",
+    "@kui-shell/builder": "11.5.0-dev-20220717-150812",
+    "@kui-shell/proxy": "11.5.0-dev-20220717-150812",
+    "@kui-shell/react": "11.5.0-dev-20220717-150812",
+    "@kui-shell/webpack": "11.5.0-dev-20220717-150812",
     "@playwright/test": "^1.23.2",
     "@types/debug": "^4.1.7",
     "@types/node": "14.11.8",
@@ -113,16 +113,16 @@
   },
   "dependencies": {
     "@kui-shell/client": "file:./plugins/plugin-client-default",
-    "@kui-shell/core": "11.5.0-dev-20220715-111236",
-    "@kui-shell/plugin-bash-like": "11.5.0-dev-20220715-111236",
-    "@kui-shell/plugin-client-common": "11.5.0-dev-20220715-111236",
+    "@kui-shell/core": "11.5.0-dev-20220717-150812",
+    "@kui-shell/plugin-bash-like": "11.5.0-dev-20220717-150812",
+    "@kui-shell/plugin-client-common": "11.5.0-dev-20220717-150812",
     "@kui-shell/plugin-codeflare": "file:./plugins/plugin-codeflare",
-    "@kui-shell/plugin-core-support": "11.5.0-dev-20220715-111236",
-    "@kui-shell/plugin-electron-components": "11.5.0-dev-20220715-111236",
-    "@kui-shell/plugin-kubectl": "11.5.0-dev-20220715-111236",
+    "@kui-shell/plugin-core-support": "11.5.0-dev-20220717-150812",
+    "@kui-shell/plugin-electron-components": "11.5.0-dev-20220717-150812",
+    "@kui-shell/plugin-kubectl": "11.5.0-dev-20220717-150812",
     "@kui-shell/plugin-madwizard": "file:./plugins/plugin-madwizard",
-    "@kui-shell/plugin-patternfly4-themes": "11.5.0-dev-20220715-111236",
-    "@kui-shell/plugin-proxy-support": "11.5.0-dev-20220715-111236",
-    "@kui-shell/plugin-s3": "11.5.0-dev-20220715-111236"
+    "@kui-shell/plugin-patternfly4-themes": "11.5.0-dev-20220717-150812",
+    "@kui-shell/plugin-proxy-support": "11.5.0-dev-20220717-150812",
+    "@kui-shell/plugin-s3": "11.5.0-dev-20220717-150812"
   }
 }

package.json

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2022 The Kubernetes Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { doExecWithPty } from "@kui-shell/plugin-bash-like"
+import { setTabReadonly } from "@kui-shell/plugin-madwizard"
+import { Arguments, encodeComponent } from "@kui-shell/core"
+
+/**
+ * Entrypoint for madwizard tasks from tray.ts. We could improve the
+ * design here. For now, we launch ourselves as a subprocess and
+ * render the results in an xterm/pty container.
+ *
+ * see bin/codeflare; we are mostly copying bits from there
+ */
+export default function guide(args: Arguments) {
+  setTabReadonly(args)
+
+  args.command = args.command =
+    encodeComponent(process.argv[0]) +
+    " " +
+    encodeComponent(process.env.CODEFLARE_HEADLESS + "/codeflare.min.js") +
+    " -- " +
+    args.command.replace(/--type=renderer/, "").replace(/^codeflare\s+guide/, "codeflare") +
+    " -a"
+
+  if (!args.execOptions.env) {
+    args.execOptions.env = {}
+  }
+
+  // not super important logic
+  args.execOptions.env.KUI_HEADLESS_WEBPACK = "true"
+  args.execOptions.env.ELECTRON_RUN_AS_NODE = "true"
+  args.execOptions.env.KUI_HEADLESS = "true"
+  args.execOptions.env.KUI_S3 = "false"
+
+  return doExecWithPty(args)
+}

plugins/plugin-codeflare/src/controller/guide.ts

@@ -41,6 +41,11 @@ export default function registerCodeflareCommands(registrar: Registrar) {
   description(registrar)
   registrar.listen("/help", help)
 
+  registrar.listen("/codeflare/guide", (args) => import("./guide").then((_) => _.default(args)), {
+    width: 1280,
+    height: 800,
+  })
+
   registrar.listen("/codeflare/get/profile", (args) => import("./profile/get").then((_) => _.default(args)), {
     needsUI: true,
   })

plugins/plugin-codeflare/src/controller/index.ts

@@ -14,8 +14,15 @@
  * limitations under the License.
  */
 
-export async function initTray(args: { command: string }, _: unknown, createWindow: (argv: string[]) => void) {
+import { CreateWindowFunction } from "@kui-shell/core"
+
+/**
+ * This logic will be executed in the electron-main process, and is
+ * called by Kui core in response to the event issued by
+ * `./tray/renderer`, whenever a new electron window opens.
+ */
+export async function initTray(args: { command: string }, _: unknown, createWindow: CreateWindowFunction) {
   if (args.command === "/tray/init") {
-    import("./tray").then((_) => _.main(createWindow))
+    import("./tray/main").then((_) => _.default(createWindow))
   }
 }

plugins/plugin-codeflare/src/electron-main.ts

@@ -16,9 +16,15 @@
 
 import { Capabilities } from "@kui-shell/core"
 
-export default async () => {
+/**
+ * This logic will be executed in the electron-renderer process, and
+ * is called by Kui core whenever a new electron window opens (and
+ * whenever a new headless process is launched; but we guard against
+ * that via `!Capabilities.isHeadless()`.
+ */
+export default async function codeflarePreload() {
   if (!Capabilities.isHeadless()) {
     const { ipcRenderer } = await import("electron")
-    import("./tray").then((_) => _.renderer(ipcRenderer))
+    import("./tray/renderer").then((_) => _.default(ipcRenderer))
   }
 }

plugins/plugin-codeflare/src/preload.ts

@@ -16,34 +16,32 @@
 
 import open from "open"
 import { join } from "path"
-import { Choices, Profiles } from "madwizard"
-import { MenuItemConstructorOptions } from "electron"
+import { Menu } from "electron"
+import { CreateWindowFunction } from "@kui-shell/core"
+
+import profilesMenu from "./profiles"
 
 import { productName } from "@kui-shell/client/config.d/name.json"
 import { bugs, version } from "@kui-shell/client/package.json"
 
+// these our are tray menu icons; the electron api specifies that if
+// the files are named fooTemplate, then it will take care of
+// rendering them as a "template icon" via underlying platform apis
 import icon from "@kui-shell/client/icons/png/codeflareTemplate.png"
 import icon2x from "@kui-shell/client/icons/png/codeflareTemplate@2x.png"
 
+// we only want one tray menu, so we need to squirrel away a reference
+// somewhere
 let tray: null | InstanceType<typeof import("electron").Tray> = null
 
-function profileMenu(state: Choices.ChoiceState): MenuItemConstructorOptions {
-  return { label: state.profile.name, type: "radio" }
-}
-
-async function profilesMenu(): Promise<MenuItemConstructorOptions> {
-  const profiles = await Profiles.list({})
-
-  return { label: "Profiles", submenu: profiles.map(profileMenu) }
-}
-
-async function buildContextMenu(createWindow: (argv: string[]) => void) {
+/** @return an Electron `Menu` model for our tray menu */
+async function buildContextMenu(createWindow: CreateWindowFunction): Promise<Menu> {
   const { Menu } = await import("electron")
 
   const contextMenu = Menu.buildFromTemplate([
     { label: `CodeFlare v${version}`, click: () => createWindow([]) },
     { type: "separator" },
-    await profilesMenu(),
+    await profilesMenu(createWindow),
     { type: "separator" },
     /* {
       label: `Test new window`,
@@ -62,7 +60,13 @@ async function buildContextMenu(createWindow: (argv: string[]) => void) {
   return contextMenu
 }
 
-export async function main(createWindow: (argv: string[]) => void) {
+/**
+ * This is the logic that will be executed in the *electron-main*
+ * process for tray menu registration. This will be invoked by our
+ * `electron-main.ts`, via the `renderer` function below, which in
+ * turn is called from our `preload.ts`.
+ */
+export default async function main(createWindow: CreateWindowFunction) {
   if (tray) {
     // only register one tray menu...
     return
@@ -97,18 +101,3 @@ export async function main(createWindow: (argv: string[]) => void) {
       console.error("Error registering electron tray menu", err)
     })
 }
-
-export async function renderer(ipcRenderer: import("electron").IpcRenderer) {
-  if (ipcRenderer) {
-    ipcRenderer.send(
-      "/exec/invoke",
-      JSON.stringify({
-        module: "plugin-codeflare",
-        main: "initTray",
-        args: {
-          command: "/tray/init",
-        },
-      })
-    )
-  }
-}

plugins/plugin-codeflare/src/tray.ts renamed to plugins/plugin-codeflare/src/tray/main.ts

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2022 The Kubernetes Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Choices, Profiles } from "madwizard"
+import { MenuItemConstructorOptions } from "electron"
+import { CreateWindowFunction } from "@kui-shell/core"
+
+import windowOptions from "./window"
+
+/** Handler for booting up a profile */
+async function boot(profile: string, createWindow: CreateWindowFunction) {
+  createWindow(
+    ["codeflare", "guide", "ml/ray/start/kubernetes", "--profile", profile],
+    windowOptions({ title: "Booting " + profile })
+  )
+}
+
+/** Handler for shutting down a profile */
+async function shutdown(profile: string, createWindow: CreateWindowFunction) {
+  createWindow(
+    ["codeflare", "guide", "ml/ray/stop/kubernetes", "--profile", profile],
+    windowOptions({ title: "Shutting down " + profile })
+  )
+}
+
+/** @return a menu for the given profile */
+function submenuForOneProfile(
+  state: Choices.ChoiceState,
+  createWindow: CreateWindowFunction
+): MenuItemConstructorOptions {
+  return {
+    label: state.profile.name,
+    submenu: [
+      { label: "Boot", click: () => boot(state.profile.name, createWindow) },
+      { label: "Shutdown", click: () => shutdown(state.profile.name, createWindow) },
+    ],
+  }
+}
+
+/** @return a menu for all profiles */
+export default async function profilesMenu(createWindow: CreateWindowFunction): Promise<MenuItemConstructorOptions> {
+  const profiles = await Profiles.list({})
+
+  return { label: "Profiles", submenu: profiles.map((_) => submenuForOneProfile(_, createWindow)) }
+}

plugins/plugin-codeflare/src/tray/profiles.ts

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2022 The Kubernetes Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This is the logic that will execute in the *electron-renderer*
+ * process for tray menu registration. This will be called by our,
+ * `preload.ts` i.e. whenever a new electron window opens.
+ *
+ * We ask the *electron-main* process to handle things. We do this by
+ * invoking the Kui `/exec/invoke` IPC API. See our
+ * `electron-main.ts`, and note how it has an `initTray` method. Here,
+ * we specify the plugin (`plugin-codeflare`), and the method to
+ * invoke (`initTray`), and the parameters to pass to that method
+ * invocation.
+ */
+export default async function renderer(ipcRenderer: import("electron").IpcRenderer) {
+  if (ipcRenderer) {
+    ipcRenderer.send(
+      "/exec/invoke",
+      JSON.stringify({
+        module: "plugin-codeflare",
+        main: "initTray",
+        args: {
+          command: "/tray/init",
+        },
+      })
+    )
+  }
+}

plugins/plugin-codeflare/src/tray/renderer.ts

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2022 The Kubernetes Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { CreateWindowFunction } from "@kui-shell/core"
+
+type NewWindowOptions = Parameters<CreateWindowFunction>[1]
+
+/** default new window options */
+const defaultNewWindowOptions: NewWindowOptions = {
+  width: 1280,
+  height: 800,
+}
+
+/** Overlay `base` options with the default new window options */
+export default function windowOptions(base: NewWindowOptions): NewWindowOptions {
+  return Object.assign({}, defaultNewWindowOptions, base)
+}