fix: remove the Fallback worker (#6254)

* fix: remove the Fallback worker

This patch removes the `Fallback` case for when there are no web workers
in the browser. If the browser is sufficiently old that it doesn't have
web worker support, things are broken much earlier than this.
Additionally, `monaco-editor` requires web workers for its own
functionality. Lastly, we shouldn't ever attempt to run the complex
CPU-bound functions in the main thread of the browser either. If this
ever did actually get used, it's likely to wreck the experience even
further.

Fixes #5832

* chore: consolidate worker code

This patch consolidates all the worker code into a single file, as it
was no longer used in multiple places.

Author: rockstar

src/languageSupport/languages/flux/lsp/monaco.flux.lsp.ts

@@ -20,12 +20,10 @@ import FLUXLANGID from 'src/languageSupport/languages/flux/monaco.flux.syntax'
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import fluxWorkerUrl from 'worker-plugin/loader!./worker/flux.worker'
-import Fallback from 'src/languageSupport/languages/flux/lsp/worker/flux.fallback'
 import {EditorType} from 'src/types'
 
 // utils
 import {reportErrorThroughHoneyBadger} from 'src/shared/utils/errors'
-import {event} from 'src/cloud/utils/reporting'
 
 // install Monaco language client services
 MonacoServices.install(monaco)
@@ -71,13 +69,7 @@ export function initLspWorker() {
   if (worker) {
     return
   }
-  if (window.Worker) {
-    event('Used LSP worker.')
-    worker = new Worker(fluxWorkerUrl)
-  } else {
-    event('Used LSP fallback worker.')
-    worker = new Fallback()
-  }
+  worker = new Worker(fluxWorkerUrl)
   worker.onerror = (err: ErrorEvent) => {
     const error: Error = {...err, name: 'worker.onerror'}
     reportErrorThroughHoneyBadger(error, {name: 'LSP worker'})

src/languageSupport/languages/flux/lsp/worker/buffer.ts

@@ -1,4 +1,89 @@
-import Buffer from 'src/languageSupport/languages/flux/lsp/worker/buffer'
+import {Lsp} from '@influxdata/flux-lsp-browser'
+import {Methods} from 'src/languageSupport/languages/flux/lsp/utils'
+
+const respond = (msg, cb) => {
+  try {
+    // LSP spec permits a blank response
+    if (!msg) {
+      return
+    }
+    const d = JSON.parse(msg)
+    cb(d)
+  } catch (e) {
+    console.error(e)
+  }
+}
+
+class Buffer {
+  private _i = 0
+  private _o = 0
+  private _initBuffer = new Array(100)
+  private _serverStartSignaled = false
+  private _initialized = false // ACK received from monaco
+  private _server: Lsp
+
+  private _insertBuffer = req => {
+    this._initBuffer[this._i % 100] = req
+    this._i++
+  }
+
+  private _consumeInitBuffer = async cb => {
+    let msg = this._initBuffer[this._o % 100]
+    do {
+      const res = await this._server.send(JSON.stringify(msg))
+      respond(res, cb)
+      this._o++
+      msg = this._initBuffer[this._o % 100]
+    } while (!!msg)
+    return
+  }
+
+  send(data, cb) {
+    // Handle race condition, because LSP is lazy loaded while init messages are received.
+    switch (
+      `${data.method}|${this._serverStartSignaled}|${this._initialized}`
+    ) {
+      case `${Methods.Initialize}|false|false`:
+        this._serverStartSignaled = true
+        const initMsg = data
+        start(cb).then(s => {
+          this._server = s
+          this._server
+            .send(JSON.stringify(initMsg))
+            .then(res => respond(res, cb))
+        })
+        break
+      case `${Methods.Initialize}|true|false`: // initialize already received
+        break
+      case `${Methods.Initialized}|true|false`:
+      case `${Methods.Initialized}|true|true`:
+        this._server.send(JSON.stringify(data)).then(async _ => {
+          await this._consumeInitBuffer(cb)
+          this._initialized = true
+        })
+        break
+      default:
+        if (!this._initialized) {
+          this._insertBuffer(data)
+        } else {
+          this._server.send(JSON.stringify(data)).then(res => respond(res, cb))
+        }
+        break
+    }
+  }
+}
+
+async function start(cb): Promise<Lsp> {
+  const {Lsp} = await import('@influxdata/flux-lsp-browser')
+  const server = new Lsp()
+  server.onMessage(d => respond(d, cb))
+  server
+    .run()
+    .then(() => console.warn('lsp server has stopped'))
+    .catch(err => console.error('lsp server has crashed', err))
+
+  return server
+}
 
 const buffer = new Buffer()