refactor stores wip

JulienChampagnol · JulienChampagnol · commit ee92d5a89bdf · 2025-04-03T17:13:30.000+02:00
diff --git a/components/Launcher.vue b/components/Launcher.vue
@@ -29,7 +29,7 @@
   watch(is_captcha_validated, async (value) => {
     if (value === true && process.client) {
       await infra_store.create_connexion()
-      await viewer_store.ws_connect()
+      await viewer_store.connect()
     }
   })
 </script>
diff --git a/components/RemoteRenderingView.vue b/components/RemoteRenderingView.vue
@@ -24,17 +24,16 @@
   import vtkRemoteView from "@kitware/vtk.js/Rendering/Misc/RemoteView"
   import { useElementSize, useWindowSize } from "@vueuse/core"
   import viewer_schemas from "@geode/opengeodeweb-viewer/schemas.json"
+  import Status from "../utils/status"
 
   const viewer_store = use_viewer_store()
-  const { client, is_running, picking_mode } = storeToRefs(viewer_store)
-
   const viewer = ref(null)
   const { width, height } = useElementSize(viewer)
 
   const { width: windowWidth, height: windowHeight } = useWindowSize()
 
   function get_x_y(event) {
-    if (picking_mode.value === true) {
+    if (viewer_store.picking_mode.value === true) {
       const { offsetX, offsetY } = event
       viewer_store.set_picked_point(offsetX, offsetY)
       viewer_call({
@@ -70,7 +69,7 @@
     resize()
   })
 
-  watch(picking_mode, (value) => {
+  watch(viewer_store.picking_mode, (value) => {
     const cursor = value ? "crosshair" : "pointer"
     view.getCanvasView().setCursor(cursor)
   })
@@ -79,7 +78,7 @@
     resize()
   })
 
-  watch(client, () => {
+  watch(viewer_store.client, () => {
     connect()
   })
 
@@ -91,10 +90,10 @@
   })
 
   function connect() {
-    if (!is_running.value) {
+    if (!viewer_store.status !== Status.CONNECTED) {
       return
     }
-    const session = client.value.getConnection().getSession()
+    const session = viewer_store.client.value.getConnection().getSession()
     view.setSession(session)
     view.setViewId(viewId.value)
     connected.value = true
diff --git a/stores/geode.js b/stores/geode.js
@@ -1,10 +1,11 @@
 import back_schemas from "@geode/opengeodeweb-back/schemas.json"
+import Status from "../utils/status"
 
 export const use_geode_store = defineStore("geode", {
   state: () => ({
     default_local_port: "5000",
     request_counter: 0,
-    is_running: false,
+    status: Status.NOT_CONNECTED,
   }),
   getters: {
     protocol() {
@@ -37,7 +38,7 @@ export const use_geode_store = defineStore("geode", {
   actions: {
     ping_task() {
       setInterval(() => {
-        if (this.is_running) {
+        if (this.status == Status.CONNECTED) {
           this.do_ping()
         }
       }, 10 * 1000)
@@ -51,17 +52,17 @@ export const use_geode_store = defineStore("geode", {
         body: {},
         onRequestError({ error }) {
           feedback_store.server_error = true
-          geode_store.is_running = false
+          geode_store.status = Status.NOT_CONNECTED
         },
         onResponse({ response }) {
           if (response.ok) {
             feedback_store.server_error = false
-            geode_store.is_running = true
+            geode_store.status = Status.CONNECTED
           }
         },
         onResponseError({ response }) {
           feedback_store.server_error = true
-          geode_store.is_running = false
+          geode_store.status = Status.NOT_CONNECTED
         },
       })
     },
@@ -72,4 +73,7 @@ export const use_geode_store = defineStore("geode", {
       this.request_counter--
     },
   },
+  share: {
+    omit: ["status"],
+  },
 })
diff --git a/stores/infra.js b/stores/infra.js
@@ -1,11 +1,12 @@
 import { useStorage } from "@vueuse/core"
 import isElectron from "is-electron"
+import Status from "../utils/status"
 
 export const use_infra_store = defineStore("infra", {
   state: () => ({
     ID: useStorage("ID", ""),
     is_captcha_validated: false,
-    is_connexion_launched: false,
+    status: Status.NOT_CREATED,
   }),
   getters: {
     is_cloud() {
@@ -34,47 +35,61 @@ export const use_infra_store = defineStore("infra", {
         "/createbackend"
       return url
     },
-    is_running() {
-      return use_geode_store().is_running && use_viewer_store().is_running
+    microservices_connected() {
+      return (
+        use_geode_store().status == Status.CONNECTED &&
+        use_viewer_store().status == Status.CONNECTED
+      )
     },
-    is_busy() {
+    microservices_busy() {
       return use_geode_store().is_busy || use_viewer_store().is_busy
     },
   },
   actions: {
-    async create_connexion() {
-      if (this.is_connexion_launched) {
-        return
-      }
-      this.is_connexion_launched = true
-      return this.create_backend()
-    },
     async create_backend() {
-      const geode_store = use_geode_store()
-      const viewer_store = use_viewer_store()
-      const feedback_store = use_feedback_store()
-
-      if (isElectron()) {
-        const back_port = await window.electronAPI.run_back(geode_store.port)
-        geode_store.$patch({ default_local_port: back_port })
-        const viewer_port = await window.electronAPI.run_viewer(
-          viewer_store.port,
-        )
-        viewer_store.$patch({ default_local_port: viewer_port })
-      } else {
-        const { data, error } = await useFetch(this.lambda_url, {
-          method: "POST",
-        })
-        if (data.value !== null) {
-          this.ID = data.value.ID
-          localStorage.setItem("ID", data.value.ID)
-        } else {
-          feedback_store.server_error = true
-          return
-        }
+      if (this.status in [Status.CREATING, Status.CREATED]) {
+        return
       }
-      geode_store.$patch({ is_running: true })
-      return geode_store.ping_task()
+      navigator.locks.request(
+        "infra.create_backend",
+        { mode: "shared" },
+        async (lock) => {
+          this.status = Status.CREATING
+          console.log("LOCK", lock)
+          if (lock) {
+            console.log("LOCKED")
+            this.status = Status.CREATING
+            const geode_store = use_geode_store()
+            const viewer_store = use_viewer_store()
+            const feedback_store = use_feedback_store()
+            if (isElectron()) {
+              const back_port = await window.electronAPI.run_back(
+                geode_store.port,
+              )
+              geode_store.$patch({ default_local_port: back_port })
+              const viewer_port = await window.electronAPI.run_viewer(
+                viewer_store.port,
+              )
+              viewer_store.$patch({ default_local_port: viewer_port })
+            } else {
+              const { data, error } = await useFetch(this.lambda_url, {
+                method: "POST",
+              })
+              if (data.value !== null) {
+                this.ID = data.value.ID
+                localStorage.setItem("ID", data.value.ID)
+              } else {
+                feedback_store.server_error = true
+                return
+              }
+            }
+            this.status = Status.CREATED
+            geode_store.ping_task()
+            viewer_store.connect()
+            return
+          }
+        },
+      )
     },
   },
 })
diff --git a/stores/viewer.js b/stores/viewer.js
@@ -2,16 +2,17 @@ import _ from "lodash"
 import vtkWSLinkClient from "@kitware/vtk.js/IO/Core/WSLinkClient"
 import "@kitware/vtk.js/Rendering/OpenGL/Profiles/Geometry"
 import schemas from "@geode/opengeodeweb-viewer/schemas.json"
+import Status from "../utils/status"
 
 export const use_viewer_store = defineStore("viewer", {
   state: () => ({
     default_local_port: "1234",
     client: {},
     config: null,
-    is_running: false,
     picking_mode: false,
     picked_point: { x: null, y: null },
     request_counter: 0,
+    status: Status.NOT_CONNECTED,
   }),
   getters: {
     protocol() {
@@ -55,71 +56,79 @@ export const use_viewer_store = defineStore("viewer", {
       this.picked_point.y = world_y
       this.picking_mode = false
     },
-    async ws_connect() {
+    async connect() {
       if (process.env.NODE_ENV == "test") {
         return
       }
-      const SmartConnect = await import("wslink/src/SmartConnect")
-      vtkWSLinkClient.setSmartConnectClass(SmartConnect)
+      navigator.locks.request("viewer.connect", async (lock) => {
+        this.status = Status.CONNECTING
+        if (lock) {
+          this.status = Status.CONNECTING
+          const SmartConnect = await import("wslink/src/SmartConnect")
+          vtkWSLinkClient.setSmartConnectClass(SmartConnect)
 
-      const config = { application: "Viewer" }
-      config.sessionURL = this.base_url
+          const config = { application: "Viewer" }
+          config.sessionURL = this.base_url
 
-      const { client } = this
-      if (this.is_running && client.isConnected()) {
-        client.disconnect(-1)
-        this.is_running = false
-      }
-      let clientToConnect = client
-      if (_.isEmpty(clientToConnect)) {
-        clientToConnect = vtkWSLinkClient.newInstance()
-      }
+          const { client } = this
+          if (this.is_running && client.isConnected()) {
+            client.disconnect(-1)
+            this.is_running = false
+          }
+          let clientToConnect = client
+          if (_.isEmpty(clientToConnect)) {
+            clientToConnect = vtkWSLinkClient.newInstance()
+          }
 
-      // Connect to busy store
-      clientToConnect.onBusyChange((count) => {
-        this.buzy = count
-      })
-      clientToConnect.beginBusy()
+          // Connect to busy store
+          clientToConnect.onBusyChange((count) => {
+            this.buzy = count
+          })
+          clientToConnect.beginBusy()
 
-      // Error
-      clientToConnect.onConnectionError((httpReq) => {
-        const message =
-          (httpReq && httpReq.response && httpReq.response.error) ||
-          `Connection error`
-        console.error(message)
-      })
+          // Error
+          clientToConnect.onConnectionError((httpReq) => {
+            const message =
+              (httpReq && httpReq.response && httpReq.response.error) ||
+              `Connection error`
+            console.error(message)
+          })
 
-      // Close
-      clientToConnect.onConnectionClose((httpReq) => {
-        const message =
-          (httpReq && httpReq.response && httpReq.response.error) ||
-          `Connection close`
-        console.error(message)
-      })
+          // Close
+          clientToConnect.onConnectionClose((httpReq) => {
+            const message =
+              (httpReq && httpReq.response && httpReq.response.error) ||
+              `Connection close`
+            console.error(message)
+          })
 
-      // Connect
-      const { connectImageStream } = await import(
-        "@kitware/vtk.js/Rendering/Misc/RemoteView"
-      )
-      return new Promise((resolve, reject) => {
-        clientToConnect
-          .connect(config)
-          .then((validClient) => {
-            connectImageStream(validClient.getConnection().getSession())
-            this.client = validClient
-            clientToConnect.endBusy()
+          // Connect
+          const { connectImageStream } = await import(
+            "@kitware/vtk.js/Rendering/Misc/RemoteView"
+          )
+          return new Promise((resolve, reject) => {
+            clientToConnect
+              .connect(config)
+              .then((validClient) => {
+                connectImageStream(validClient.getConnection().getSession())
+                this.client = validClient
+                clientToConnect.endBusy()
 
-            // Now that the client is ready let's setup the server for us
-            viewer_call({
-              schema: schemas.opengeodeweb_viewer.viewer.reset_visualization,
-            })
-            this.is_running = true
-            resolve()
-          })
-          .catch((error) => {
-            console.error(error)
-            reject(error)
+                // Now that the client is ready let's setup the server for us
+                viewer_call({
+                  schema:
+                    schemas.opengeodeweb_viewer.viewer.reset_visualization,
+                })
+                this.status = Status.CONNECTED
+                resolve()
+              })
+              .catch((error) => {
+                console.error(error)
+                this.status = Status.NOT_CONNECTED
+                reject(error)
+              })
           })
+        }
       })
     },
     start_request() {
@@ -129,4 +138,7 @@ export const use_viewer_store = defineStore("viewer", {
       this.request_counter--
     },
   },
+  share: {
+    omit: ["status", "client"],
+  },
 })
diff --git a/utils/status.js b/utils/status.js
@@ -0,0 +1,10 @@
+const Status = {
+  NOT_CREATED: "NOT_CREATED",
+  CREATING: "CREATING",
+  CREATED: "CREATED",
+  NOT_CONNECTED: "NOT_CONNECTED",
+  CONNECTING: "CONNECTING",
+  CONNECTED: "CONNECTED",
+}
+
+export default Status

Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@`
`29`	`29`	`watch(is_captcha_validated, async (value) => {`
`30`	`30`	`if (value === true && process.client) {`
`31`	`31`	`await infra_store.create_connexion()`
`32`		`- await viewer_store.ws_connect()`
	`32`	`+ await viewer_store.connect()`
`33`	`33`	`}`
`34`	`34`	`})`
`35`	`35`	`</script>`