backend mocking for reqs that alter state

ui/src/app/services/api/mock-api.service.ts

@@ -1,35 +1,23 @@
 import { Injectable } from '@angular/core'
 import { pauseFor } from '../../util/misc.util'
 import { ApiService } from './api.service'
-import { Observable } from 'rxjs'
+import { PatchOp } from 'patch-db-client'
-import { PatchOp, Store, Update } from 'patch-db-client'
+import { PackageDataEntry, PackageMainStatus, PackageState, ServerStatus } from 'src/app/services/patch-db/data-model'
-import { DataModel, PackageDataEntry, PackageMainStatus, PackageState, ServerStatus } from 'src/app/services/patch-db/data-model'
+import { RR, WithRevision } from './api-types'
-import { RR } from './api-types'
 import { parsePropertiesPermissive } from 'src/app/util/properties.util'
 import { Mock } from './mock-app-fixures'
 import { HttpService } from '../http.service'
 import markdown from 'raw-loader!src/assets/markdown/md-sample.md'
+import { revision } from '@start9labs/emver'
 
 @Injectable()
 export class MockApiService extends ApiService {
-  sequence = 0
   welcomeAck = false
 
   constructor (
     private readonly http: HttpService,
   ) { super() }
 
-  // every time a patch is returned from the mock, we override its sequence to be 1 more than the last sequence in the patch-db as provided by `o`.
-  watch$ (store: Store<DataModel>): Observable<Update<DataModel>> {
-    store.sequence$.subscribe(seq => {
-      console.log('INCOMING: ', seq)
-      if (this.sequence < seq) {
-        this.sequence = seq
-      }
-    })
-    return super.watch$()
-  }
-
   async getStatic (url: string): Promise<string> {
     await pauseFor(2000)
     return markdown
@@ -100,20 +88,14 @@ export class MockApiService extends ApiService {
 
   async updateServerRaw (params: RR.UpdateServerReq): Promise<RR.UpdateServerRes> {
     await pauseFor(2000)
-    return {
+    const patch = [
-      response: null,
+      {
-      revision: {
+        op: PatchOp.REPLACE,
-        id: this.nextSequence(),
+        path: '/server-info/status',
-        patch: [
+        value: ServerStatus.Updating,
-          {
-            op: PatchOp.REPLACE,
-            path: '/server-info/status',
-            value: ServerStatus.Updating,
-          },
-        ],
-        expireId: null,
       },
-    }
+    ]
+    return this.http.rpcRequest({ method: 'db.patch', params: { patch } })
   }
 
   async restartServer (params: RR.RestartServerReq): Promise<RR.RestartServerRes> {
@@ -137,39 +119,31 @@ export class MockApiService extends ApiService {
 
   async setRegistryRaw (params: RR.SetRegistryReq): Promise<RR.SetRegistryRes> {
     await pauseFor(2000)
-    return {
+    const patch = [
-      response: null,
+      {
-      revision: {
+        op: PatchOp.REPLACE,
-        id: this.nextSequence(),
+        path: '/server-info/registry',
-        patch: [
+        value: params.url,
-          {
-            op: PatchOp.REPLACE,
-            path: '/server-info/registry',
-            value: params.url,
-          },
-        ],
-        expireId: null,
       },
-    }
+    ]
+    return this.http.rpcRequest({ method: 'db.patch', params: { patch } })
   }
 
   // notification
 
   async getNotificationsRaw (params: RR.GetNotificationsReq): Promise<RR.GetNotificationsRes> {
     await pauseFor(2000)
+    const patch = [
+      {
+        op: PatchOp.REPLACE,
+        path: '/server-info/unread-notification-count',
+        value: 0,
+      },
+    ]
+    const { revision } = await this.http.rpcRequest({ method: 'db.patch', params: { patch } }) as WithRevision<null>
     return {
       response: Mock.Notifications,
-      revision: {
+      revision,
-        id: this.nextSequence(),
-        patch: [
-          {
-            op: PatchOp.REPLACE,
-            path: '/server-info/unread-notification-count',
-            value: 0,
-          },
-        ],
-        expireId: null,
-      },
     }
   }
 
@@ -187,48 +161,36 @@ export class MockApiService extends ApiService {
 
   async connectWifiRaw (params: RR.ConnectWifiReq): Promise<RR.ConnectWifiRes> {
     await pauseFor(2000)
-    return {
+    const patch = [
-      response: null,
+      {
-      revision: {
+        op: PatchOp.REPLACE,
-        id: this.nextSequence(),
+        path: '/server-info/wifi/selected',
-        patch: [
+        value: params.ssid,
-          {
-            op: PatchOp.REPLACE,
-            path: '/server-info/wifi/selected',
-            value: params.ssid,
-          },
-          {
-            op: PatchOp.REPLACE,
-            path: '/server-info/wifi/connected',
-            value: params.ssid,
-          },
-        ],
-        expireId: null,
       },
-    }
+      {
+        op: PatchOp.REPLACE,
+        path: '/server-info/wifi/connected',
+        value: params.ssid,
+      },
+    ]
+    return this.http.rpcRequest({ method: 'db.patch', params: { patch } })
   }
 
   async deleteWifiRaw (params: RR.DeleteWifiReq): Promise<RR.DeleteWifiRes> {
     await pauseFor(2000)
-    return {
+    const patch = [
-      response: null,
+      {
-      revision: {
+        op: PatchOp.REPLACE,
-        id: this.nextSequence(),
+        path: '/server-info/wifi/selected',
-        patch: [
+        value: null,
-          {
-            op: PatchOp.REPLACE,
-            path: '/server-info/wifi/selected',
-            value: null,
-          },
-          {
-            op: PatchOp.REPLACE,
-            path: '/server-info/wifi/connected',
-            value: null,
-          },
-        ],
-        expireId: null,
       },
-    }
+      {
+        op: PatchOp.REPLACE,
+        path: '/server-info/wifi/connected',
+        value: null,
+      },
+    ]
+    return this.http.rpcRequest({ method: 'db.patch', params: { patch } })
   }
 
   // ssh
@@ -252,20 +214,14 @@ export class MockApiService extends ApiService {
 
   async createBackupRaw (params: RR.CreateBackupReq): Promise<RR.CreateBackupRes> {
     await pauseFor(2000)
-    return {
+    const patch = [
-      response: null,
+      {
-      revision: {
+        op: PatchOp.REPLACE,
-        id: this.nextSequence(),
+        path: '/server-info/status',
-        patch: [
+        value: ServerStatus.BackingUp,
-          {
-            op: PatchOp.REPLACE,
-            path: '/server-info/status',
-            value: ServerStatus.BackingUp,
-          },
-        ],
-        expireId: null,
       },
-    }
+    ]
+    return this.http.rpcRequest({ method: 'db.patch', params: { patch } })
   }
 
   async restoreBackupRaw (params: RR.RestoreBackupReq): Promise<RR.RestoreBackupRes> {
@@ -314,20 +270,14 @@ export class MockApiService extends ApiService {
         'read-complete': false,
       },
     }
-    return {
+    const patch = [
-      response: null,
+      {
-      revision: {
+        op: PatchOp.ADD,
-        id: this.nextSequence(),
+        path: `/package-data/${params.id}`,
-        patch: [
+        value: pkg,
-          {
-            op: PatchOp.ADD,
-            path: `/package-data/${params.id}`,
-            value: pkg,
-          },
-        ],
-        expireId: null,
       },
-    }
+    ]
+    return this.http.rpcRequest({ method: 'db.patch', params: { patch } })
   }
 
   async dryUpdatePackage (params: RR.DryUpdatePackageReq): Promise<RR.DryUpdatePackageRes> {
@@ -347,43 +297,31 @@ export class MockApiService extends ApiService {
 
   async setPackageConfigRaw (params: RR.SetPackageConfigReq): Promise<RR.SetPackageConfigRes> {
     await pauseFor(2000)
-    return {
+    const patch = [
-      response: null,
+      {
-      revision: {
+        op: PatchOp.REPLACE,
-        id: this.nextSequence(),
+        path: `/package-data/${params.id}/installed/status/configured`,
-        patch: [
+        value: true,
-          {
-            op: PatchOp.REPLACE,
-            path: `/package-data/${params.id}/installed/status/configured`,
-            value: true,
-          },
-          {
-            op: PatchOp.REPLACE,
-            path: `/package-data/${params.id}/installed/status/main/status`,
-            value: PackageMainStatus.Running,
-          },
-        ],
-        expireId: null,
       },
-    }
+      {
+        op: PatchOp.REPLACE,
+        path: `/package-data/${params.id}/installed/status/main/status`,
+        value: PackageMainStatus.Running,
+      },
+    ]
+    return this.http.rpcRequest({ method: 'db.patch', params: { patch } })
   }
 
   async restorePackageRaw (params: RR.RestorePackageReq): Promise<RR.RestorePackageRes> {
     await pauseFor(2000)
-    return {
+    const patch = [
-      response: null,
+      {
-      revision: {
+        op: PatchOp.REPLACE,
-        id: this.nextSequence(),
+        path: `/package-data/${params.id}/installed/status/main/status`,
-        patch: [
+        value: PackageMainStatus.Restoring,
-          {
-            op: PatchOp.REPLACE,
-            path: `/package-data/${params.id}/installed/status/main/status`,
-            value: PackageMainStatus.Restoring,
-          },
-        ],
-        expireId: null,
       },
-    }
+    ]
+    return this.http.rpcRequest({ method: 'db.patch', params: { patch } })
   }
 
   async executePackageAction (params: RR.ExecutePackageActionReq): Promise<RR.ExecutePackageActionRes> {
@@ -398,20 +336,14 @@ export class MockApiService extends ApiService {
 
   async startPackageRaw (params: RR.StartPackageReq): Promise<RR.StartPackageRes> {
     await pauseFor(2000)
-    return {
+    const patch = [
-      response: null,
+      {
-      revision: {
+        op: PatchOp.REPLACE,
-        id: this.nextSequence(),
+        path: `/package-data/${params.id}/installed/status/main/status`,
-        patch: [
+        value: PackageMainStatus.Running,
-          {
-            op: PatchOp.REPLACE,
-            path: `/package-data/${params.id}/installed/status/main/status`,
-            value: PackageMainStatus.Running,
-          },
-        ],
-        expireId: null,
       },
-    }
+    ]
+    return this.http.rpcRequest({ method: 'db.patch', params: { patch } })
   }
 
   async dryStopPackage (params: RR.DryStopPackageReq): Promise<RR.DryStopPackageRes> {
@@ -421,20 +353,26 @@ export class MockApiService extends ApiService {
 
   async stopPackageRaw (params: RR.StopPackageReq): Promise<RR.StopPackageRes> {
     await pauseFor(2000)
-    return {
+    const patch = [
-      response: null,
+      {
-      revision: {
+        op: PatchOp.REPLACE,
-        id: this.nextSequence(),
+        path: `/package-data/${params.id}/installed/status/main/status`,
-        patch: [
+        value: PackageMainStatus.Stopping,
-          {
-            op: PatchOp.REPLACE,
-            path: `/package-data/${params.id}/installed/status/main/status`,
-            value: PackageMainStatus.Stopping,
-          },
-        ],
-        expireId: null,
       },
-    }
+    ]
+    const res = await this.http.rpcRequest<WithRevision<null>>({ method: 'db.patch', params: { patch } })
+    setTimeout(() => {
+      const patch = [
+        {
+          op: PatchOp.REPLACE,
+          path: `/package-data/${params.id}/installed/status/main/status`,
+          value: PackageMainStatus.Stopped,
+        },
+      ]
+      this.http.rpcRequest<WithRevision<null>>({ method: 'db.patch', params: { patch } })
+    }, 2000)
+
+    return res
   }
 
   async dryRemovePackage (params: RR.DryRemovePackageReq): Promise<RR.DryRemovePackageRes> {
@@ -444,20 +382,14 @@ export class MockApiService extends ApiService {
 
   async removePackageRaw (params: RR.RemovePackageReq): Promise<RR.RemovePackageRes> {
     await pauseFor(2000)
-    return {
+    const patch = [
-      response: null,
+      {
-      revision: {
+        op: PatchOp.REPLACE,
-        id: this.nextSequence(),
+        path: `/package-data/${params.id}/state`,
-        patch: [
+        value: PackageState.Removing,
-          {
-            op: PatchOp.REPLACE,
-            path: `/package-data/${params.id}/state`,
-            value: PackageState.Removing,
-          },
-        ],
-        expireId: null,
       },
-    }
+    ]
+    return this.http.rpcRequest({ method: 'db.patch', params: { patch } })
   }
 
   async dryConfigureDependency (params: RR.DryConfigureDependencyReq): Promise<RR.DryConfigureDependencyRes> {
@@ -488,10 +420,4 @@ export class MockApiService extends ApiService {
     await pauseFor(2000)
     return Mock.AvailableShow[params.id][params.version || 'latest']
   }
-
-  private nextSequence () {
-    console.log('next')
-    this.sequence++
-    return this.sequence
-  }
 }

ui/src/app/services/patch-db/patch-db.factory.ts

@@ -31,5 +31,5 @@ export function PatchDbModelFactory (
     }
   }
 
-  return new PatchDbModel(bootstrapper, [source, apiService])
+  return new PatchDbModel(source, apiService, bootstrapper)
 }

ui/src/app/services/patch-db/patch-db.service.ts

@@ -1,11 +1,13 @@
 import { Inject, Injectable, InjectionToken } from '@angular/core'
 import { Bootstrapper, PatchDB, Source, Store } from 'patch-db-client'
 import { BehaviorSubject, Observable, of, Subscription } from 'rxjs'
-import { catchError, debounceTime, map, tap } from 'rxjs/operators'
+import { catchError, debounceTime, finalize, map, tap } from 'rxjs/operators'
+import { ApiService } from '../api/api.service'
 import { DataModel } from './data-model'
 
-export const BOOTSTRAPPER = new InjectionToken<Bootstrapper<DataModel>>('app.config')
+export const PATCH_HTTP = new InjectionToken<Source<DataModel>>('app.config')
 export const PATCH_SOURCE = new InjectionToken<Source<DataModel>>('app.config')
+export const BOOTSTRAPPER = new InjectionToken<Bootstrapper<DataModel>>('app.config')
 
 export enum ConnectionStatus {
   Initializing = 'initializing',
@@ -24,13 +26,14 @@ export class PatchDbModel {
   private patchSub: Subscription
 
   constructor (
+    @Inject(PATCH_SOURCE) private readonly source: Source<DataModel>,
+    @Inject(PATCH_HTTP) private readonly http: ApiService,
     @Inject(BOOTSTRAPPER) private readonly bootstrapper: Bootstrapper<DataModel>,
-    @Inject(PATCH_SOURCE) private readonly sources: Source<DataModel>[],
   ) { }
 
   async init (): Promise<void> {
     const cache = await this.bootstrapper.init()
-    this.patchDb = new PatchDB(this.sources, cache)
+    this.patchDb = new PatchDB([this.source, this.http], this.http, cache)
 
     this.sequence$ = this.patchDb.store.sequence$.asObservable()
     this.data = this.patchDb.store.cache.data
@@ -81,14 +84,14 @@ export class PatchDbModel {
   }
 
   watch$: Store<DataModel>['watch$'] = (...args: (string | number)[]): Observable<DataModel> => {
-    // console.log('WATCHING')
+    console.log('WATCHING', ...args)
     return this.patchDb.store.watch$(...(args as [])).pipe(
       tap(cache => console.log('CHANGE IN STORE', cache)),
       catchError(e => {
         console.error(e)
         return of(e.message)
       }),
-      // finalize(() => console.log('unSUBSCRIBing')),
+      finalize(() => console.log('UNSUBSCRIBING')),
     )
   }
 }

ui/ui-config.json

@@ -10,7 +10,7 @@
   },
   "mocks": {
     "enabled": true,
-    "connection": "poll",
+    "connection": "ws",
     "rpcPort": "5959",
     "wsPort": "5960",
     "maskAs": "tor",