Merge branch 'next/minor' of github.com:Start9Labs/start-os into next/major

web/projects/ui/src/app/services/api/embassy-mock-api.service.ts

@@ -2,10 +2,12 @@ import { Injectable } from '@angular/core'
 import { pauseFor, Log, RPCErrorDetails, RPCOptions } from '@start9labs/shared'
 import { ApiService } from './embassy-api.service'
 import {
+  AddOperation,
   Operation,
   PatchOp,
   pathFromArray,
   RemoveOperation,
+  ReplaceOperation,
   Revision,
 } from 'patch-db-client'
 import {
@@ -81,10 +83,8 @@ export class MockApiService extends ApiService {
       .subscribe()
   }
 
-  async uploadPackage(guid: string, body: Blob): Promise<string> {
+  async uploadPackage(guid: string, body: Blob): Promise<void> {
     await pauseFor(2000)
-    // @TODO Aiden confirm this is correct
-    return 'success'
   }
 
   async uploadFile(body: Blob): Promise<string> {
@@ -112,7 +112,7 @@ export class MockApiService extends ApiService {
 
   openWebsocket$<T>(
     guid: string,
-    config: RR.WebsocketConfig<T>,
+    config: RR.WebsocketConfig<T> = {},
   ): Observable<T> {
     if (guid === 'db-guid') {
       return this.mockWsSource$.pipe<any>(
@@ -131,6 +131,11 @@ export class MockApiService extends ApiService {
       return from(this.initProgress()).pipe(
         startWith(PROGRESS),
       ) as Observable<T>
+    } else if (guid === 'sideload-progress-guid') {
+      config.openObserver?.next(new Event(''))
+      return from(this.initProgress()).pipe(
+        startWith(PROGRESS),
+      ) as Observable<T>
     } else {
       throw new Error('invalid guid type')
     }
@@ -909,14 +914,14 @@ export class MockApiService extends ApiService {
 
   async createBackup(params: RR.CreateBackupReq): Promise<RR.CreateBackupRes> {
     await pauseFor(2000)
-    const path = '/serverInfo/statusInfo/backupProgress'
+    const serverPath = '/serverInfo/statusInfo/backupProgress'
     const ids = params.packageIds
 
     setTimeout(async () => {
       for (let i = 0; i < ids.length; i++) {
         const id = ids[i]
-        const appPath = `/packageData/${id}/status/main/status`
-        const appPatch = [
+        const appPath = `/packageData/${id}/status/main/`
+        const appPatch: ReplaceOperation<T.MainStatus['main']>[] = [
           {
             op: PatchOp.REPLACE,
             path: appPath,
@@ -933,40 +938,43 @@ export class MockApiService extends ApiService {
             value: 'stopped',
           },
         ])
-        this.mockRevision([
+
+        const serverPatch: ReplaceOperation<T.BackupProgress['complete']>[] = [
           {
             op: PatchOp.REPLACE,
-            path: `${path}/${id}/complete`,
+            path: `${serverPath}/${id}/complete`,
             value: true,
           },
-        ])
+        ]
+        this.mockRevision(serverPatch)
       }
 
       await pauseFor(1000)
 
-      // set server back to running
-      const lastPatch = [
+      // remove backupProgress
+      const lastPatch: ReplaceOperation<T.ServerStatus['backupProgress']>[] = [
         {
           op: PatchOp.REPLACE,
-          path,
+          path: serverPath,
           value: null,
         },
       ]
       this.mockRevision(lastPatch)
     }, 500)
 
-    const originalPatch = [
-      {
-        op: PatchOp.REPLACE,
-        path,
-        value: ids.reduce((acc, val) => {
-          return {
-            ...acc,
-            [val]: { complete: false },
-          }
-        }, {}),
-      },
-    ]
+    const originalPatch: ReplaceOperation<T.ServerStatus['backupProgress']>[] =
+      [
+        {
+          op: PatchOp.REPLACE,
+          path: serverPath,
+          value: ids.reduce((acc, val) => {
+            return {
+              ...acc,
+              [val]: { complete: false },
+            }
+          }, {}),
+        },
+      ]
 
     this.mockRevision(originalPatch)
 
@@ -975,15 +983,6 @@ export class MockApiService extends ApiService {
 
   // package
 
-  async getPackageProperties(
-    params: RR.GetPackagePropertiesReq,
-  ): Promise<RR.GetPackagePropertiesRes> {
-    await pauseFor(2000)
-    return {
-      password: 'specialPassword$',
-    }
-  }
-
   async getPackageLogs(
     params: RR.GetPackageLogsReq,
   ): Promise<RR.GetPackageLogsRes> {
@@ -1025,7 +1024,7 @@ export class MockApiService extends ApiService {
       this.installProgress(params.id)
     }, 1000)
 
-    const patch: Operation<
+    const patch: AddOperation<
       PackageDataEntry<InstallingState | UpdatingState>
     >[] = [
       {
@@ -1055,44 +1054,43 @@ export class MockApiService extends ApiService {
     return null
   }
 
-  async getPackageConfig(
-    params: RR.GetPackageConfigReq,
-  ): Promise<RR.GetPackageConfigRes> {
+  async getActionInput(
+    params: RR.GetActionInputReq,
+  ): Promise<RR.GetActionInputRes> {
     await pauseFor(2000)
     return {
-      config: Mock.MockConfig,
-      spec: await Mock.getInputSpec(),
+      value: Mock.MockConfig,
+      spec: await Mock.getActionInputSpec(),
     }
   }
 
-  async drySetPackageConfig(
-    params: RR.DrySetPackageConfigReq,
-  ): Promise<RR.DrySetPackageConfigRes> {
+  async runAction(params: RR.ActionReq): Promise<RR.ActionRes> {
     await pauseFor(2000)
-    return []
-  }
 
-  async setPackageConfig(
-    params: RR.SetPackageConfigReq,
-  ): Promise<RR.SetPackageConfigRes> {
-    await pauseFor(2000)
-    const patch = [
-      {
-        op: PatchOp.REPLACE,
-        path: `/packageData/${params.id}/status/configured`,
-        value: true,
-      },
-    ]
-    this.mockRevision(patch)
-
-    return null
+    if (params.actionId === 'properties') {
+      // return Mock.ActionResGroup
+      return Mock.ActionResMessage
+      // return Mock.ActionResSingle
+    } else if (params.actionId === 'config') {
+      const patch: RemoveOperation[] = [
+        {
+          op: PatchOp.REMOVE,
+          path: `/packageData/${params.packageId}/requestedActions/${params.packageId}-config`,
+        },
+      ]
+      this.mockRevision(patch)
+      return null
+    } else {
+      return Mock.ActionResMessage
+      // return Mock.ActionResSingle
+    }
   }
 
   async restorePackages(
     params: RR.RestorePackagesReq,
   ): Promise<RR.RestorePackagesRes> {
     await pauseFor(2000)
-    const patch: Operation<PackageDataEntry>[] = params.ids.map(id => {
+    const patch: AddOperation<PackageDataEntry>[] = params.ids.map(id => {
       setTimeout(async () => {
         this.installProgress(id)
       }, 2000)
@@ -1118,50 +1116,62 @@ export class MockApiService extends ApiService {
     return null
   }
 
-  async executePackageAction(
-    params: RR.ExecutePackageActionReq,
-  ): Promise<RR.ExecutePackageActionRes> {
-    await pauseFor(2000)
-    return Mock.ActionResponse
-  }
-
   async startPackage(params: RR.StartPackageReq): Promise<RR.StartPackageRes> {
-    const path = `/packageData/${params.id}/status/main`
+    const path = `/packageData/${params.id}/status`
 
     await pauseFor(2000)
 
     setTimeout(async () => {
-      if (params.id !== 'bitcoind') {
-        const patch2 = [
-          {
-            op: PatchOp.REPLACE,
-            path: path + '/health',
-            value: {},
+      const patch2: ReplaceOperation<T.MainStatus & { main: 'running' }>[] = [
+        {
+          op: PatchOp.REPLACE,
+          path,
+          value: {
+            main: 'running',
+            started: new Date().toISOString(),
+            health: {
+              'ephemeral-health-check': {
+                name: 'Ephemeral Health Check',
+                result: 'starting',
+                message: null,
+              },
+              'unnecessary-health-check': {
+                name: 'Unnecessary Health Check',
+                result: 'disabled',
+                message: 'Custom disabled message',
+              },
+              'chain-state': {
+                name: 'Chain State',
+                result: 'loading',
+                message: 'Bitcoin is syncing from genesis',
+              },
+              'p2p-interface': {
+                name: 'P2P Interface',
+                result: 'success',
+                message: null,
+              },
+              'rpc-interface': {
+                name: 'RPC Interface',
+                result: 'failure',
+                message: 'Custom failure message',
+              },
+            },
           },
-        ]
-        this.mockRevision(patch2)
-      }
-
-      const patch3 = [
-        {
-          op: PatchOp.REPLACE,
-          path: path + '/status',
-          value: 'running',
-        },
-        {
-          op: PatchOp.REPLACE,
-          path: path + '/started',
-          value: new Date().toISOString(),
         },
       ]
-      this.mockRevision(patch3)
+      this.mockRevision(patch2)
     }, 2000)
 
-    const originalPatch = [
+    const originalPatch: ReplaceOperation<
+      T.MainStatus & { main: 'starting' }
+    >[] = [
       {
         op: PatchOp.REPLACE,
-        path: path + '/status',
-        value: 'starting',
+        path,
+        value: {
+          main: 'starting',
+          health: {},
+        },
       },
     ]
 
@@ -1173,74 +1183,57 @@ export class MockApiService extends ApiService {
   async restartPackage(
     params: RR.RestartPackageReq,
   ): Promise<RR.RestartPackageRes> {
-    // first enact stop
     await pauseFor(2000)
-    const path = `/packageData/${params.id}/status/main`
+    const path = `/packageData/${params.id}/status`
 
     setTimeout(async () => {
-      const patch2: Operation<any>[] = [
+      const patch2: ReplaceOperation<T.MainStatus & { main: 'running' }>[] = [
         {
           op: PatchOp.REPLACE,
-          path: path + '/status',
-          value: 'starting',
-        },
-        {
-          op: PatchOp.ADD,
-          path: path + '/restarting',
-          value: true,
+          path,
+          value: {
+            main: 'running',
+            started: new Date().toISOString(),
+            health: {
+              'ephemeral-health-check': {
+                name: 'Ephemeral Health Check',
+                result: 'starting',
+                message: null,
+              },
+              'unnecessary-health-check': {
+                name: 'Unnecessary Health Check',
+                result: 'disabled',
+                message: 'Custom disabled message',
+              },
+              'chain-state': {
+                name: 'Chain State',
+                result: 'loading',
+                message: 'Bitcoin is syncing from genesis',
+              },
+              'p2p-interface': {
+                name: 'P2P Interface',
+                result: 'success',
+                message: null,
+              },
+              'rpc-interface': {
+                name: 'RPC Interface',
+                result: 'failure',
+                message: 'Custom failure message',
+              },
+            },
+          },
         },
       ]
       this.mockRevision(patch2)
-
-      await pauseFor(2000)
-
-      const patch3: Operation<any>[] = [
-        {
-          op: PatchOp.REPLACE,
-          path: path + '/status',
-          value: 'running',
-        },
-        {
-          op: PatchOp.REMOVE,
-          path: path + '/restarting',
-        },
-        {
-          op: PatchOp.REPLACE,
-          path: path + '/health',
-          value: {
-            'ephemeral-health-check': {
-              result: 'starting',
-            },
-            'unnecessary-health-check': {
-              result: 'disabled',
-            },
-            'chain-state': {
-              result: 'loading',
-              message: 'Bitcoin is syncing from genesis',
-            },
-            'p2p-interface': {
-              result: 'success',
-            },
-            'rpc-interface': {
-              result: 'failure',
-              error: 'RPC interface unreachable.',
-            },
-          },
-        } as any,
-      ]
-      this.mockRevision(patch3)
     }, this.revertTime)
 
-    const patch = [
+    const patch: ReplaceOperation<T.MainStatus & { main: 'restarting' }>[] = [
       {
         op: PatchOp.REPLACE,
-        path: path + '/status',
-        value: 'restarting',
-      },
-      {
-        op: PatchOp.REPLACE,
-        path: path + '/health',
-        value: {},
+        path,
+        value: {
+          main: 'restarting',
+        },
       },
     ]
 
@@ -1251,29 +1244,24 @@ export class MockApiService extends ApiService {
 
   async stopPackage(params: RR.StopPackageReq): Promise<RR.StopPackageRes> {
     await pauseFor(2000)
-    const path = `/packageData/${params.id}/status/main`
+    const path = `/packageData/${params.id}/status`
 
     setTimeout(() => {
-      const patch2 = [
+      const patch2: ReplaceOperation<T.MainStatus & { main: 'stopped' }>[] = [
         {
           op: PatchOp.REPLACE,
           path: path,
-          value: {
-            status: 'stopped',
-          },
+          value: { main: 'stopped' },
         },
       ]
       this.mockRevision(patch2)
     }, this.revertTime)
 
-    const patch = [
+    const patch: ReplaceOperation<T.MainStatus & { main: 'stopping' }>[] = [
       {
         op: PatchOp.REPLACE,
         path: path,
-        value: {
-          status: 'stopping',
-          timeout: '35s',
-        },
+        value: { main: 'stopping' },
       },
     ]
 
@@ -1282,6 +1270,12 @@ export class MockApiService extends ApiService {
     return null
   }
 
+  async rebuildPackage(
+    params: RR.RebuildPackageReq,
+  ): Promise<RR.RebuildPackageRes> {
+    return this.restartPackage(params)
+  }
+
   async uninstallPackage(
     params: RR.UninstallPackageReq,
   ): Promise<RR.UninstallPackageRes> {
@@ -1297,7 +1291,7 @@ export class MockApiService extends ApiService {
       this.mockRevision(patch2)
     }, this.revertTime)
 
-    const patch = [
+    const patch: ReplaceOperation<T.PackageState['state']>[] = [
       {
         op: PatchOp.REPLACE,
         path: `/packageData/${params.id}/stateInfo/state`,
@@ -1310,22 +1304,11 @@ export class MockApiService extends ApiService {
     return null
   }
 
-  async dryConfigureDependency(
-    params: RR.DryConfigureDependencyReq,
-  ): Promise<RR.DryConfigureDependencyRes> {
-    await pauseFor(2000)
-    return {
-      oldConfig: Mock.MockConfig,
-      newConfig: Mock.MockDependencyConfig,
-      spec: await Mock.getInputSpec(),
-    }
-  }
-
   async sideloadPackage(): Promise<RR.SideloadPackageRes> {
     await pauseFor(2000)
     return {
-      upload: '4120e092-05ab-4de2-9fbd-c3f1f4b1df9e', // no significance, randomly generated
-      progress: '5120e092-05ab-4de2-9fbd-c3f1f4b1df9e', // no significance, randomly generated
+      upload: 'sideload-upload-guid', // no significance, randomly generated
+      progress: 'sideload-progress-guid', // no significance, randomly generated
     }
   }