Extract ResourceDisk to its own file

src/action.ts

@@ -11,6 +11,7 @@ import flatMap from 'array.prototype.flatmap'
 import * as architecture from './architecture'
 import * as hostModule from './host'
 import * as os from './operating_system'
+import ResourceDisk from './resource_disk'
 import * as vmModule from './vm'
 
 export enum ImplementationKind {
@@ -19,13 +20,14 @@ export enum ImplementationKind {
 }
 
 export class Action {
+  readonly tempPath: string
+  readonly host: hostModule.Host
+  readonly operatingSystem: os.OperatingSystem
+
   private readonly input = new Input()
   private readonly resourceDisk: ResourceDisk
-  private readonly operatingSystem: os.OperatingSystem
   private readonly implementation: Implementation
-  private readonly host: hostModule.Host
   private readonly workDirectory
-  private readonly tempPath: string
   private readonly sshDirectory: string
   private readonly privateSshKey: fs.PathLike
   private readonly publicSshKey: fs.PathLike
@@ -35,14 +37,15 @@ export class Action {
   constructor() {
     this.host = hostModule.Host.create()
     this.tempPath = fs.mkdtempSync('/tmp/resources')
-    this.resourceDisk = new ResourceDisk(this.tempPath, this.host)
 
     this.operatingSystem = os.OperatingSystem.create(
       this.input.operatingSystem,
       architecture.Kind.x86_64,
       this.input.version
     )
 
+    this.resourceDisk = ResourceDisk.for(this)
+
     this.implementation = this.getImplementation(
       this.operatingSystem.actionImplementationKind
     )
@@ -308,69 +311,6 @@ class QemuImplementation extends Implementation {
   }
 }
 
-class ResourceDisk {
-  readonly diskPath: string
-
-  private readonly mountName = 'RES'
-  private mountPath!: string
-
-  private readonly host: hostModule.Host
-  private readonly tempPath: string
-  private devicePath!: string
-
-  constructor(tempPath: string, host: hostModule.Host) {
-    this.host = host
-    this.tempPath = tempPath
-    this.diskPath = path.join(this.tempPath, 'res.raw')
-  }
-
-  async create(): Promise<string> {
-    core.debug('Creating resource disk')
-    await this.createDiskFile()
-    this.devicePath = await this.createDiskDevice()
-    await this.partitionDisk()
-
-    const mountPath = path.join(this.tempPath, 'mount/RES')
-
-    return (this.mountPath = await this.mountDisk(mountPath))
-  }
-
-  async unmount(): Promise<void> {
-    await this.unmountDisk()
-    await this.detachDevice()
-  }
-
-  private async createDiskFile(): Promise<void> {
-    core.debug('Creating disk file')
-    await this.host.createDiskFile('40m', this.diskPath)
-  }
-
-  private async createDiskDevice(): Promise<string> {
-    core.debug('Creating disk file')
-    return await this.host.createDiskDevice(this.diskPath)
-  }
-
-  private async partitionDisk(): Promise<void> {
-    core.debug('Partitioning disk')
-    await this.host.partitionDisk(this.devicePath, this.mountName)
-  }
-
-  private async mountDisk(mountPath: string): Promise<string> {
-    core.debug('mounting disk')
-    return await this.host.mountDisk(this.devicePath, mountPath)
-  }
-
-  private async unmountDisk(): Promise<void> {
-    core.debug('Unmounting disk')
-    await exec.exec('sudo', ['umount', this.mountPath])
-  }
-
-  private async detachDevice(): Promise<void> {
-    core.debug('Detaching device')
-    await this.host.detachDevice(this.devicePath)
-  }
-}
-
 class Input {
   private run_?: string
   private operatingSystem_?: os.Kind

src/host.ts

@@ -1,13 +1,7 @@
-import {promises as fs} from 'fs'
 import * as process from 'process'
-import * as os from 'os'
-
-import * as exec from '@actions/exec'
 
 import * as architecture from './architecture'
 import * as qemu from './qemu_vm'
-import {execWithOutput} from './utility'
-import path from 'path'
 import * as xhyve from './xhyve_vm'
 
 export enum Kind {
@@ -39,6 +33,11 @@ export function toString(value: Kind): string {
   }
 }
 
+interface Implementation<MacOsType, LinuxType> {
+  macos: MacOsType
+  linux: LinuxType
+}
+
 export abstract class Host {
   static create(): Host {
     switch (kind) {
@@ -53,12 +52,11 @@ export abstract class Host {
 
   abstract get workDirectory(): string
   abstract get vmModule(): typeof xhyve | typeof qemu
+  abstract resolve<MacOsType, LinuxType>(
+    implementation: Implementation<MacOsType, LinuxType>
+  ): MacOsType | LinuxType
+
   abstract canRunXhyve(arch: architecture.Architecture): boolean
-  abstract createDiskFile(size: string, diskPath: string): Promise<void>
-  abstract createDiskDevice(diskPath: string): Promise<string>
-  abstract partitionDisk(devicePath: string, mountName: string): Promise<void>
-  abstract mountDisk(devicePath: string, mountPath: string): Promise<string>
-  abstract detachDevice(devicePath: string): Promise<void>
 }
 
 class MacOs extends Host {
@@ -70,48 +68,14 @@ class MacOs extends Host {
     return xhyve
   }
 
-  canRunXhyve(arch: architecture.Architecture): boolean {
-    return arch.kind === architecture.Kind.x86_64
+  resolve<MacOs, Linux>(
+    implementation: Implementation<MacOs, Linux>
+  ): MacOs | Linux {
+    return implementation.macos
   }
 
-  async createDiskFile(size: string, diskPath: string): Promise<void> {
-    await exec.exec('mkfile', ['-n', size, diskPath])
-  }
-
-  async createDiskDevice(diskPath: string): Promise<string> {
-    const devicePath = await execWithOutput(
-      'hdiutil',
-      [
-        'attach',
-        '-imagekey',
-        'diskimage-class=CRawDiskImage',
-        '-nomount',
-        diskPath
-      ],
-      {silent: true}
-    )
-
-    return devicePath.trim()
-  }
-
-  async partitionDisk(devicePath: string, mountName: string): Promise<void> {
-    await exec.exec('diskutil', [
-      'partitionDisk',
-      devicePath,
-      '1',
-      'GPT',
-      'fat32',
-      mountName,
-      '100%'
-    ])
-  }
-
-  async mountDisk(_devicePath: string, mountPath: string): Promise<string> {
-    return path.join('/Volumes', path.basename(mountPath))
-  }
-
-  async detachDevice(devicePath: string): Promise<void> {
-    await exec.exec('hdiutil', ['detach', devicePath])
+  canRunXhyve(arch: architecture.Architecture): boolean {
+    return arch.kind === architecture.Kind.x86_64
   }
 }
 
@@ -130,59 +94,10 @@ class Linux extends Host {
     return false
   }
 
-  async createDiskFile(size: string, diskPath: string): Promise<void> {
-    await exec.exec('truncate', ['-s', size, diskPath])
-
-    const input = Buffer.from('n\np\n1\n\n\nw\n')
-    // technically, this is partitioning the disk
-    await exec.exec('fdisk', [diskPath], {input})
-  }
-
-  async createDiskDevice(diskPath: string): Promise<string> {
-    // the offset and size limit are retrieved by running:
-    // `sfdisk -d ${diskPath}` and multiply the start and size by 512.
-    // https://checkmk.com/linux-knowledge/mounting-partition-loop-device
-
-    // prettier-ignore
-    const devicePath = await execWithOutput(
-      'sudo',
-      [
-        'losetup',
-        '-f',
-        '--show',
-        '--offset', '1048576',
-        '--sizelimit', '40894464',
-        diskPath
-      ],
-      {silent: true}
-    )
-
-    return devicePath.trim()
-  }
-
-  /* eslint-disable  @typescript-eslint/no-unused-vars */
-  async partitionDisk(devicePath: string, _mountName: string): Promise<void> {
-    /* eslint-enable  @typescript-eslint/no-unused-vars */
-    // technically, this is creating the filesystem on the partition
-    await exec.exec('sudo', ['mkfs.fat', '-F32', devicePath])
-  }
-
-  async mountDisk(devicePath: string, mountPath: string): Promise<string> {
-    await fs.mkdir(mountPath, {recursive: true})
-    const uid = os.userInfo().uid
-    await exec.exec('sudo', [
-      'mount',
-      '-o',
-      `uid=${uid}`,
-      devicePath,
-      mountPath
-    ])
-
-    return mountPath
-  }
-
-  async detachDevice(devicePath: string): Promise<void> {
-    await exec.exec('sudo', ['losetup', '-d', devicePath])
+  resolve<MacOs, Linux>(
+    implementation: Implementation<MacOs, Linux>
+  ): MacOs | Linux {
+    return implementation.linux
   }
 }