refactor: deployer to device

Author: Groupguanfang

.changeset/cozy-cooks-bake.md

@@ -0,0 +1,5 @@
+---
+"@arkts/image-manager": patch
+---
+
+refactor: deployer to device

README.md

@@ -49,33 +49,33 @@ async function main() {
     throw new Error('MateBook Fold not found')
 
   // Create the deployer
-  const deployer = image.createDeployer('MateBook Fold', createDeployedImageConfig(image))
+  const device = image.createDevice('MateBook Fold', createDeployedImageConfig(image))
     .setCpuNumber(4)
     .setMemoryRamSize(4096)
     .setDataDiskSize(6144)
 
   // We can get the final deployed image options,
   // it will be written to the `imageBasePath/lists.json` file when deployed.
-  const list = await deployer.buildList()
+  const list = await device.buildList()
   console.warn(list)
 
   // We can get the `config.ini` object,
   // it will be written to the `deployedPath/MateBook Fold/config.ini` file when deployed.
-  const config = await deployer.buildIni()
+  const config = await device.buildIni()
   console.warn(config)
   // You also can get the `config.ini` string version:
-  const iniString = await deployer.toIniString()
+  const iniString = await device.toIniString()
   console.warn(iniString)
 
-  // Deploy the image
-  await deployer.deploy()
+  // Deploy the device
+  await device.deploy()
   console.warn('Image deployed successfully')
 
   // Start the emulator
-  await image.start(deployer)
+  await image.start(device)
 
   await new Promise<void>(resolve => setTimeout(resolve, 1000 * 60))
   // Stop the emulator
-  image.stop(deployer)
+  image.stop(device)
 }
 ```

src/deployer/image-deployer.ts

@@ -1,8 +1,8 @@
 import type { LocalImage } from '../images'
 import type { LocalImageImpl } from '../images/local-image'
-import type { DeployedDevModel, DeployedImageConfigWithProductName, DeployedImageOptions, FullDeployedImageOptions } from './list'
+import type { DeployedDevModel, DeployedImageOptions, FullDeployedImageOptions, ProductNameable } from './list'
 
-export interface ImageDeployer {
+export interface Device {
   setUuid(uuid: `${string}-${string}-${string}-${string}-${string}`): this
   setModel(model: string): this
   setDevModel(devModel: FullDeployedImageOptions['devModel']): this
@@ -36,14 +36,26 @@ export interface ImageDeployer {
    */
   toIniString(): Promise<string>
   /**
-   * Deploy the image.
+   * Deploy the device.
    *
    * @param symlinkImage - If true, symlink the system image to current device directory. Default is `true`.
    */
   deploy(symlinkImage?: boolean): Promise<void | Error>
+  /**
+   * Check if the device is deployed.
+   *
+   * @returns True if the device is deployed, false otherwise.
+   */
+  isDeployed(): Promise<boolean>
+  /**
+   * Delete the device.
+   *
+   * @returns True if the device is deleted, false otherwise.
+   */
+  delete(): Promise<void | Error>
 }
 
-class ImageDeployerImpl implements ImageDeployer {
+class ImageDeployerImpl implements Device {
   private readonly options: Partial<FullDeployedImageOptions> = {}
   private isDefault = true
   private isCustomize = false
@@ -55,11 +67,13 @@ class ImageDeployerImpl implements ImageDeployer {
     private readonly image: LocalImageImpl,
     uuid: string,
     name: string,
-    private readonly config: DeployedImageConfigWithProductName,
+    private readonly config: ProductNameable<FullDeployedImageOptions>,
   ) {
     this.options.uuid = uuid
     this.options.name = name
     Object.assign(this.options, config)
+    if ('productName' in this.options)
+      delete this.options.productName
   }
 
   setUuid(uuid: string): this {
@@ -290,13 +304,37 @@ class ImageDeployerImpl implements ImageDeployer {
     }
     return undefined
   }
+
+  async isDeployed(): Promise<boolean> {
+    const { fs, path } = this.image.getImageManager().getOptions()
+    const listsPath = path.resolve(this.image.getImageManager().getOptions().deployedPath, 'lists.json')
+    if (!fs.existsSync(listsPath) || !fs.statSync(listsPath).isFile())
+      return false
+    const lists: FullDeployedImageOptions[] = JSON.parse(fs.readFileSync(listsPath, 'utf-8')) ?? []
+    return lists.find(item => item.name === this.options.name) !== undefined
+  }
+
+  async delete(): Promise<void | Error> {
+    const { fs, path } = this.image.getImageManager().getOptions()
+    const listsPath = path.resolve(this.image.getImageManager().getOptions().deployedPath, 'lists.json')
+    if (!fs.existsSync(listsPath) || !fs.statSync(listsPath).isFile())
+      return new Error('Lists file not found')
+    const lists: FullDeployedImageOptions[] = JSON.parse(fs.readFileSync(listsPath, 'utf-8')) ?? []
+    const index = lists.findIndex(item => item.name === this.options.name)
+    if (index === -1)
+      return new Error(`Device ${this.options.name} not found`)
+    lists.splice(index, 1)
+    fs.writeFileSync(listsPath, JSON.stringify(lists, null, 2))
+    fs.rmSync(path.resolve(this.options.path ?? ''), { recursive: true })
+    return undefined
+  }
 }
 
 export function createImageDeployer(
   image: LocalImage,
   uuid: string,
   name: string,
-  config: DeployedImageConfigWithProductName,
-): ImageDeployer {
+  config: ProductNameable<FullDeployedImageOptions>,
+): Device {
   return new ImageDeployerImpl(image as LocalImageImpl, uuid, name, config)
 }

src/deployer/index.ts

@@ -1,2 +1,2 @@
-export type { ImageDeployer } from './image-deployer'
+export type { Device } from './image-deployer'
 export * from './list'

src/deployer/list.ts

@@ -19,6 +19,15 @@ export type DeployedDevModel
     | DevModel
     | (string & {})
 
+export type ProductNameable<T> = T & {
+  /**
+   * The name of the product.
+   *
+   * @example 'Mate 80 Pro Max、Mate 80 RS'
+   */
+  productName: string
+}
+
 export interface DeployedImageConfig {
   /**
    * Diagonal size.

src/images/local-image.ts

@@ -1,5 +1,5 @@
-import type { ImageDeployer } from '../deployer/image-deployer'
-import type { DeployedImageConfigWithProductName } from '../deployer/list'
+import type { Device } from '../deployer/image-deployer'
+import type { DeployedImageConfigWithProductName, FullDeployedImageOptions, ProductNameable } from '../deployer/list'
 import type { ProductConfigItem } from '../product-config'
 import type { DeviceType, Stringifiable } from '../types'
 import type { BaseImage } from './image'
@@ -8,13 +8,14 @@ import { ImageBase } from './image'
 
 export interface LocalImage extends BaseImage, Stringifiable<LocalImage.Stringifiable> {
   imageType: 'local'
-  createDeployer(name: string, config: DeployedImageConfigWithProductName): ImageDeployer
+  createDevice(name: string, config: DeployedImageConfigWithProductName): Device
   getProductConfig(): Promise<ProductConfigItem[]>
   delete(): Promise<void | Error>
-  buildStartCommand(deployer: ImageDeployer): Promise<string>
-  start(deployer: ImageDeployer): Promise<import('node:child_process').ChildProcess>
-  buildStopCommand(deployer: ImageDeployer): Promise<string>
-  stop(deployer: ImageDeployer): Promise<import('node:child_process').ChildProcess>
+  buildStartCommand(deployer: Device): Promise<string>
+  start(deployer: Device): Promise<import('node:child_process').ChildProcess>
+  buildStopCommand(deployer: Device): Promise<string>
+  stop(deployer: Device): Promise<import('node:child_process').ChildProcess>
+  getDevices(): Promise<Device[]>
 }
 
 export namespace LocalImage {
@@ -27,7 +28,7 @@ export namespace LocalImage {
 export class LocalImageImpl extends ImageBase<LocalImage.Stringifiable> implements LocalImage {
   imageType = 'local' as const
 
-  createDeployer(name: string, config: DeployedImageConfigWithProductName): ImageDeployer {
+  createDevice(name: string, config: ProductNameable<FullDeployedImageOptions>): Device {
     return createImageDeployer(
       this,
       this.getImageManager().getOptions().crypto.randomUUID(),
@@ -52,11 +53,16 @@ export class LocalImageImpl extends ImageBase<LocalImage.Stringifiable> implemen
   }
 
   async delete(): Promise<void | Error> {
-    const fs = this.getImageManager().getOptions().fs
+    const { fs } = this.getImageManager().getOptions()
     const path = this.getFsPath()
     if (!fs.existsSync(path) || !fs.statSync(path).isDirectory())
       return new Error('Image path does not exist')
     fs.rmSync(path, { recursive: true })
+    const devices = await this.getDevices()
+    const error = await Promise.allSettled(devices.map(device => device.delete()))
+      .then(results => results.find(result => result.status === 'rejected'))
+    if (error)
+      return error.reason
     return undefined
   }
 
@@ -65,7 +71,7 @@ export class LocalImageImpl extends ImageBase<LocalImage.Stringifiable> implemen
     return process.platform === 'win32' ? path.join(emulatorPath, 'Emulator.exe') : path.join(emulatorPath, 'Emulator')
   }
 
-  async buildStartCommand(deployer: ImageDeployer): Promise<string> {
+  async buildStartCommand(deployer: Device): Promise<string> {
     const config = await deployer.buildList()
     const executablePath = this.getExecutablePath()
     const args = [
@@ -79,12 +85,12 @@ export class LocalImageImpl extends ImageBase<LocalImage.Stringifiable> implemen
     return `${executablePath} ${args}`
   }
 
-  async start(deployer: ImageDeployer): Promise<import('node:child_process').ChildProcess> {
+  async start(deployer: Device): Promise<import('node:child_process').ChildProcess> {
     const { child_process, emulatorPath } = this.getImageManager().getOptions()
     return child_process.exec(await this.buildStartCommand(deployer), { cwd: emulatorPath })
   }
 
-  async buildStopCommand(deployer: ImageDeployer): Promise<string> {
+  async buildStopCommand(deployer: Device): Promise<string> {
     const config = await deployer.buildList()
     const executablePath = this.getExecutablePath()
     const args = [
@@ -94,11 +100,38 @@ export class LocalImageImpl extends ImageBase<LocalImage.Stringifiable> implemen
     return `${executablePath} ${args}`
   }
 
-  async stop(deployer: ImageDeployer): Promise<import('node:child_process').ChildProcess> {
+  async stop(deployer: Device): Promise<import('node:child_process').ChildProcess> {
     const { child_process, emulatorPath } = this.getImageManager().getOptions()
     return child_process.exec(await this.buildStopCommand(deployer), { cwd: emulatorPath })
   }
 
+  private typeAssert<T>(value: unknown): asserts value is T {}
+
+  async getDevices(): Promise<Device[]> {
+    const { path, fs, imageBasePath } = this.getImageManager().getOptions()
+    const listsJsonPath = path.resolve(this.getImageManager().getOptions().deployedPath, 'lists.json')
+    if (!fs.existsSync(listsJsonPath) || !fs.statSync(listsJsonPath).isFile())
+      return []
+    const listsJson: unknown = JSON.parse(fs.readFileSync(listsJsonPath, 'utf-8'))
+    if (!Array.isArray(listsJson) || this.imageType !== 'local')
+      return []
+
+    this.typeAssert<LocalImage>(this)
+    const devices: Device[] = []
+    for (const listsJsonItem of listsJson as unknown[]) {
+      if (typeof listsJsonItem !== 'object' || listsJsonItem === null)
+        continue
+      if (!('imageDir' in listsJsonItem) || typeof listsJsonItem.imageDir !== 'string')
+        continue
+      if (!('name' in listsJsonItem) || typeof listsJsonItem.name !== 'string')
+        continue
+      if (path.resolve(this.getFsPath()) !== path.resolve(imageBasePath, listsJsonItem.imageDir))
+        continue
+      devices.push(this.createDevice(listsJsonItem.name, listsJsonItem as ProductNameable<FullDeployedImageOptions>))
+    }
+    return devices
+  }
+
   toJSON(): LocalImage.Stringifiable {
     return {
       ...super.toJSON(),

test/index.test.ts

@@ -62,7 +62,7 @@ describe.sequential('image manager', (it) => {
     if (!mateBookFold)
       throw new Error('MateBook Fold not found')
     const uuid = crypto.randomUUID()
-    const deployer = image.createDeployer('MateBook Fold', createDeployedImageConfig(mateBookFold))
+    const deployer = image.createDevice('MateBook Fold', createDeployedImageConfig(mateBookFold))
       .setCpuNumber(4)
       .setMemoryRamSize(4096)
       .setDataDiskSize(6144)
@@ -201,6 +201,6 @@ describe.skip('start', (it) => {
     const mateBookFold = productConfig.find(item => item.name === 'MateBook Fold')
     if (!mateBookFold)
       throw new Error('MateBook Fold not found')
-    await image.start(image.createDeployer('MateBook Fold', createDeployedImageConfig(mateBookFold)))
+    await image.start(image.createDevice('MateBook Fold', createDeployedImageConfig(mateBookFold)))
   }, 1000 * 1000)
 })