Ensure waiting for the bridged IP after starting/resuming

Author: nktpro

cli.sh

@@ -1,5 +1,6 @@
 #!/usr/bin/env bash
 set -euo pipefail
+SCRIPT_DIR=$(realpath "$(dirname "${BASH_SOURCE[0]}")")
 
 code_quality() {
   echo "Checking formatting..."
@@ -13,18 +14,18 @@ auto_fmt() {
 }
 
 update_cache() {
-  deno cache --lock=deno.lock ./src/deps.ts ./src/app.ts
+  deno cache --lock=deno.lock "${SCRIPT_DIR}"/src/deps.ts "${SCRIPT_DIR}"/src/app.ts
 }
 
 update_lock() {
   rm -f deno.lock
-  deno cache --reload ./src/deps.ts ./src/app.ts
-  deno cache ./src/deps.ts ./src/app.ts --lock ./deno.lock --lock-write
+  deno cache --reload "${SCRIPT_DIR}"/src/deps.ts "${SCRIPT_DIR}"/src/app.ts
+  deno cache "${SCRIPT_DIR}"/src/deps.ts "${SCRIPT_DIR}"/src/app.ts --lock ./deno.lock --lock-write
 }
 
 run() {
   export JETSKI_ENABLE_STACKTRACE=${JETSKI_ENABLE_STACKTRACE:-"0"}
-  deno run -A --check ./src/app.ts "$@"
+  deno run -A --check "${SCRIPT_DIR}"/src/app.ts "$@"
 }
 
 "$@"

deno.lock

@@ -4,6 +4,7 @@ import {
   cyan,
   ExitCode,
   fsExists,
+  gray,
   inheritExec,
   joinPath,
   parseYaml,
@@ -88,8 +89,11 @@ export async function createInstance(instance: InstanceConfig) {
   const cloudInitConfig = createCloudInitConfig({ sshPublicKey, instance });
   const tempDir = await Deno.makeTempDir();
   const cloudInitFilePath = joinPath(tempDir, "cloud-init.yaml");
-  ok("Generated cloud-init.yaml");
-  ok(stringifyYaml(cloudInitConfig));
+  log("Generated cloud-init.yaml");
+  log(gray("--"));
+  log(gray("# Begin cloud-init.yaml"));
+  log(gray(stringifyYaml(cloudInitConfig)));
+  log(gray("# End cloud-init.yaml"));
   await Deno.writeTextFile(cloudInitFilePath, stringifyYaml(cloudInitConfig));
 
   const cloudInitLogTailingAbort = new AbortController();

src/actions/create.ts

@@ -18,6 +18,7 @@ export { parse as parseYaml, stringify as stringifyYaml } from "https://deno.lan
 export type { YAMLError } from "https://deno.land/[email protected]/yaml/_error.ts";
 
 export { exists as fsExists } from "https://deno.land/[email protected]/fs/exists.ts";
+export { assertExists } from "https://deno.land/[email protected]/assert/assert_exists.ts";
 export { memoizePromise } from "https://deno.land/x/[email protected]/async_utils.ts";
 
 export { delay } from "https://deno.land/[email protected]/async/delay.ts";

src/deps.ts

@@ -1,4 +1,5 @@
 import {
+  assertExists,
   captureExec,
   cyan,
   delay,
@@ -14,7 +15,7 @@ import {
   validate,
 } from "./deps.ts";
 import { InstanceConfig, InstanceState, MultipassInfo } from "./types.ts";
-import { getSshIp, log, print } from "./utils.ts";
+import { getSshIp, log, ok, print } from "./utils.ts";
 
 export const multipassBin = memoizePromise(() => locateMultipassBin());
 
@@ -293,15 +294,45 @@ export async function multipassPostStart(
   instance: InstanceConfig,
 ): Promise<string> {
   const { name, sshDirectoryPath } = instance;
-  const { state, ipv4 } = await multipassInfo({ name });
+  const { state } = await multipassInfo({ name });
 
   if (state !== InstanceState.Running) {
     throw new Error(
       `Instance '${instance.name}' is not in 'Running' state. Current state is '${state}'`,
     );
   }
 
-  const ip = getSshIp(ipv4, instance.filterSshIpByCidr);
+  let ip: string | undefined = undefined;
+
+  if (instance.filterSshIpByCidr) {
+    const maxAttempts = 30;
+    for (let i = 0; i < maxAttempts; i++) {
+      let ipv4: string[] = [];
+
+      try {
+        ipv4 = (await multipassInfo({ name })).ipv4;
+        ip = getSshIp(ipv4, instance.filterSshIpByCidr);
+      } catch (e) {
+        if (i === maxAttempts - 1) {
+          throw e;
+        }
+
+        log(
+          "Waiting for the instance's IP that matches the CIDR filter:",
+          instance.filterSshIpByCidr,
+          "So far got:",
+          ipv4.length > 0 ? ipv4.join(", ") : "none",
+        );
+        await delay(1000);
+      }
+    }
+  } else {
+    ip = getSshIp((await multipassInfo({ name })).ipv4);
+  }
+
+  assertExists(ip);
+
+  ok("Got instance IP", ip);
 
   await multipassResolveClusterLocalDns({ ip, instance });
 
@@ -444,6 +475,8 @@ export async function multipassRoute(
           `'New-NetRoute -DestinationPrefix ${cidr} -InterfaceAlias "vEthernet (Default Switch)" -NextHop ${ip}'`,
         ],
         stdin: { inherit: true },
+        stdout: { read: printOutLines((line) => `${gray("[$ New-NetRoute ]")} ${line}`) },
+        stderr: { read: printErrLines((line) => `${gray("[$ New-NetRoute ]")} ${line}`) },
       });
     }
 
@@ -454,25 +487,33 @@ export async function multipassRoute(
         `'Add-DnsClientNrptRule -Namespace ".svc.${clusterDomain}" -DnsSecEnable -NameServers "${clusterDnsIp}"'`,
       ],
       stdin: { inherit: true },
+      stdout: { read: printOutLines((line) => `${gray("[$ Add-DnsClientNrptRule ]")} ${line}`) },
+      stderr: { read: printErrLines((line) => `${gray("[$ Add-DnsClientNrptRule ]")} ${line}`) },
     });
   } else {
     log("Adding routes, will require root permissions...");
     for (const cidr of [clusterCidr, serviceCidr]) {
       await inheritExec({
         cmd: ["sudo", "/sbin/route", "add", "-net", cidr, ip],
         stdin: { inherit: true },
+        stdout: { read: printOutLines((line) => `${gray("[$ route ]")} ${line}`) },
+        stderr: { read: printErrLines((line) => `${gray("[$ route ]")} ${line}`) },
       });
     }
 
     await inheritExec({
       cmd: ["sudo", "mkdir", "-p", "/etc/resolver"],
+      stdout: { read: printOutLines((line) => `${gray("[$ resolver ]")} ${line}`) },
+      stderr: { read: printErrLines((line) => `${gray("[$ resolver ]")} ${line}`) },
     });
 
     await inheritExec({
       cmd: ["sudo", "tee", `/etc/resolver/svc.${clusterDomain}`],
       stdin: {
         pipe: [`domain svc.${clusterDomain}`, `nameserver ${clusterDnsIp}`, "search_order 1", ""].join("\n"),
       },
+      stdout: { read: printOutLines((line) => `${gray("[$ resolver ]")} ${line}`) },
+      stderr: { read: printErrLines((line) => `${gray("[$ resolver ]")} ${line}`) },
     });
   }
 }

src/multipass.ts

@@ -188,19 +188,19 @@ export async function print(...params: string[]) {
   });
 }
 
-export function log(...params: string[]) {
+export function log(...params: unknown[]) {
   console.error.apply(console, params);
 }
 
-export function out(...params: string[]) {
+export function out(...params: unknown[]) {
   console.log.apply(console, params);
 }
 
-export function ok(...params: string[]) {
+export function ok(...params: unknown[]) {
   console.error.apply(console, [green("[Success]"), ...params]);
 }
 
-export function err(...params: string[]) {
+export function err(...params: unknown[]) {
   console.error.apply(console, [red("[Error]"), ...params]);
 }