Answering questions using worker poolz

src/utils/classes.ts

@@ -254,6 +254,7 @@ function compareData(q1: Question, q2: Question) {
     logger.DebugLog('Error comparing data', 'Compare question data', 1)
     logger.DebugLog(error.message, 'Compare question data', 1)
     logger.DebugLog(error, 'Compare question data', 2)
+    console.error(error)
   }
   return 0
 }
@@ -273,7 +274,7 @@ function compareQuestionObj(
   q2subjName: string,
   data: QuestionData
 ) {
-  assert(data)
+  assert(data !== undefined || data !== null)
   assert(q1)
   assert(typeof q1 === 'object')
   assert(q2)
@@ -321,12 +322,7 @@ function questionToString(question: Question) {
 // ---------------------------------------------------------------------------------------------------------
 // Subject
 // ---------------------------------------------------------------------------------------------------------
-function searchQuestion(
-  subj: Subject,
-  question: Question,
-  questionData: QuestionData,
-  subjName: string
-) {
+function searchQuestion(subj: Subject, question: Question, subjName: string) {
   assert(question)
 
   let result = []
@@ -336,7 +332,7 @@ function searchQuestion(
       subjName,
       question,
       subj.Name,
-      questionData
+      question.data
     )
 
     if (percent.avg > minMatchAmmount) {
@@ -409,19 +405,6 @@ function addQuestion(
   }
 }
 
-function searchDatas(
-  data: Array<QuestionDb>,
-  question: any,
-  subjName: string,
-  questionData?: QuestionData
-): Promise<Array<SearchResult>> {
-  return Promise.all(
-    data.map((db: QuestionDb) => {
-      return searchData(db, question, subjName, questionData)
-    })
-  )
-}
-
 function prepareQuestion(
   question: string | Question,
   data: string | QuestionData
@@ -518,14 +501,21 @@ function dataToString(data: Array<Subject>): string {
 
 // ------------------------------------------------------------------------
 
-function searchWorker(
+function doSearch(
   data: Array<Subject>,
   subjName: string,
-  question: Question,
+  question: Question | string,
   questionData?: QuestionData
 ): any {
   let result = []
 
+  const questionToSearch =
+    typeof question === 'string'
+      ? createQuestion(question, null, questionData || { type: 'simple' })
+      : question
+
+  assert(questionToSearch.data)
+
   data.forEach((subj) => {
     if (
       subjName
@@ -533,9 +523,7 @@ function searchWorker(
         .includes(getSubjNameWithoutYear(subj.Name).toLowerCase())
     ) {
       logger.DebugLog(`Searching in ${subj.Name} `, 'searchworker', 2)
-      result = result.concat(
-        searchQuestion(subj, question, questionData, subjName)
-      )
+      result = result.concat(searchQuestion(subj, questionToSearch, subjName))
     }
   })
 
@@ -552,9 +540,7 @@ function searchWorker(
       1
     )
     data.forEach((subj) => {
-      result = result.concat(
-        searchQuestion(subj, question, questionData, subjName)
-      )
+      result = result.concat(searchQuestion(subj, questionToSearch, subjName))
     })
     if (result.length > 0) {
       logger.DebugLog(
@@ -576,8 +562,7 @@ function searchWorker(
     }
   })
 
-  parentPort.postMessage(result)
-  process.exit(0)
+  return result
 }
 
 const workerTs = (file: string, wkOpts: any) => {
@@ -598,51 +583,42 @@ const workerTs = (file: string, wkOpts: any) => {
   )
 }
 
-// if (!isMainThread) {
-//   logger.DebugLog(`Starting search worker ...`, 'searchworker', 1)
-//   const { data, subjName, question, questionData } = workerData
-//   searchWorker(data, subjName, question, questionData)
-// }
-
-function random(min, max) {
-  return Math.floor(Math.random() * (max - min) + min)
-}
-
 if (!isMainThread) {
   const workerIndex = workerData.workerIndex
-  const timeoutMin = workerData.workerTimeoutMin
-  const timeoutMax = workerData.workerTimeoutMax
-  const data = { val: 0 }
+  // TODO: check if thread independent
 
-  console.log(
+  logger.Log(
     `[THREAD #${workerIndex}]: Worker ${workerIndex} reporting for duty`
   )
-  console.log(`[THREAD #${workerIndex}]: data`, workerData)
-  // parentPort.postMessage('hello parent port')
 
   parentPort.on('message', (msg) => {
-    // console.log(`[THREAD #${workerIndex}]: onmsg`, msg)
-
     if (msg.type === 'work') {
+      const { qdb, subjName, question, questionData } = msg.data
       const index = msg.index
       console.log(`[THREAD #${workerIndex}]: staring work on ${index}`)
-      setTimeout(() => {
-        data.val = data.val + msg.add
-        parentPort.postMessage({
-          msg: `From thread #${workerIndex}: job ${index} done`,
-          workerIndex: workerIndex,
-          result: data.val,
-        })
 
-        console.log(`[THREAD #${workerIndex}]: Work ${index} done!`)
-      }, random(timeoutMin, timeoutMax))
+      let searchResult = null
+      try {
+        searchResult = doSearch(qdb, subjName, question, questionData)
+      } catch (err) {
+        logger.Log('Error in worker thread!', logger.GetColor('redbg'))
+        console.error(err)
+      }
+
+      // ONDONE:
+      parentPort.postMessage({
+        msg: `From thread #${workerIndex}: job ${index} done`,
+        workerIndex: workerIndex,
+        result: searchResult,
+      })
+
+      console.log(`[THREAD #${workerIndex}]: Work ${index} done!`)
     } else if (msg.type === 'update') {
       if (msg.data.workerIndex !== workerIndex) {
+        // TODO
+        // qdbs = msg.qdb
         console.log(`[THREAD #${workerIndex}]: update`, msg.data)
-        console.log(
-          `[THREAD #${workerIndex}]: From ${data.val} to ${msg.data.result}`
-        )
-        data.val = msg.data.result
+        console.log(`[THREAD #${workerIndex}]: From ... to ${msg.data.result}`)
       }
     }
   })
@@ -658,6 +634,5 @@ export {
   createQuestion,
   addQuestion,
   searchData,
-  searchDatas,
   dataToString,
 }