Timeout generation with an error if the template generation is taking forever (#1539)

- In template-engine.js, produceContent function, timing out the handlebars template handler if it takes more than a certain amount of time for generation because this can lead to ZAP just hanging forever.
- Also throwing errors when there is no content generated out of a generation template file
- Cleaning up the promises in generateAllTemplates because it was incorrect
Fixing the deferred loading and generation in templates with after clause

- In the after helper, adding it to the global deferred block array
- In template engine adding deferredblock to the context and then later adding it to the content
- Removing the entire global.promises.push(syncPromise) which makes the generation of templates hang. Look at the test case which makes this hang
- Adding tests to make sure templates no longer hang and also noticing substantial improvement in our generation time after this change
- This also allows better usage of promised handlebar helpers where you can now do {{#if promise}} if required
- Github: ZAP#792

Author: brdandu

src-electron/generator/generation-engine.js

@@ -711,8 +711,6 @@ async function generateAllTemplates(
     genTemplateJsonPkg.id
   )
   let generationTemplates = []
-  let helperPromises = []
-  let partialPromises = []
   let overridePath = null
 
   let hb = templateEngine.hbInstance()
@@ -746,9 +744,7 @@ async function generateAllTemplates(
   // Next load the partials
   packages.forEach((singlePkg) => {
     if (singlePkg.type == dbEnum.packageType.genPartial) {
-      partialPromises.push(
-        templateEngine.loadPartial(hb, singlePkg.category, singlePkg.path)
-      )
+      templateEngine.loadPartial(hb, singlePkg.category, singlePkg.path)
     }
   })
 
@@ -765,9 +761,7 @@ async function generateAllTemplates(
   // Next load the addon helpers which were not yet initialized earlier.
   packages.forEach((singlePkg) => {
     if (singlePkg.type == dbEnum.packageType.genHelper) {
-      helperPromises.push(
-        templateEngine.loadHelper(hb, singlePkg.path, context)
-      )
+      templateEngine.loadHelper(hb, singlePkg.path, context)
     }
   })
 
@@ -789,10 +783,6 @@ async function generateAllTemplates(
     }
   })
 
-  // And finally go over the actual templates.
-  await Promise.all(helperPromises)
-  await Promise.all(partialPromises)
-
   if (options.generateSequentially) {
     await util.executePromisesSequentially(generationTemplates, (t) =>
       generateSingleTemplate(hb, metaInfo, genResult, t, genTemplateJsonPkg, {
@@ -810,6 +800,11 @@ async function generateAllTemplates(
     await Promise.all(templates)
   }
 
+  if (genResult.hasErrors) {
+    for (const [key, value] of Object.entries(genResult.errors)) {
+      console.error(`${key}: ${value}`)
+    }
+  }
   genResult.partial = false
   return genResult
 }
@@ -852,6 +847,9 @@ async function generateSingleTemplate(
       options
     )
     for (let result of resultArray) {
+      if (!result.content) {
+        console.error(`No content generated for ${result.key}`)
+      }
       genResult.content[result.key] = result.content
       genResult.stats[result.key] = result.stats
     }

src-electron/generator/helper-zap.js

@@ -383,6 +383,7 @@ async function after(options) {
     global: this.global,
     parent: this
   }
+  this.global.deferredBlocks.push(options.fn)
   return options.fn(newContext)
 }
 

src-electron/generator/template-engine.js

@@ -70,6 +70,8 @@ const precompiledTemplates = {}
 
 const handlebarsInstance = {}
 
+const TEMPLATE_RENDER_TIMEOUT = 90000 // 90 seconds
+
 /**
  * Resolves into a precompiled template, either from previous precompile or freshly compiled.
  * @param {*} singleTemplatePkg
@@ -185,13 +187,48 @@ async function produceContent(
           return null
         }
       },
-      stats: {}
+      stats: {},
+      deferredBlocks: []
     }
   }
   if (options.initialContext != null) {
     Object.assign(context, options.initialContext)
   }
-  let content = await template(context)
+  let content
+  // Render the template but if it does not render within
+  // TEMPLATE_RENDER_TIMEOUT then throw an error instead of just hanging
+  // forever.
+  try {
+    // Attempt to render the template
+    content = await Promise.race([
+      template(context),
+      new Promise((_, reject) =>
+        setTimeout(
+          () => reject(new Error('Template rendering timed out')),
+          TEMPLATE_RENDER_TIMEOUT
+        )
+      )
+    ])
+    // Render deferred blocks
+    for (let deferredBlock of context.global.deferredBlocks) {
+      content += await deferredBlock(context)
+    }
+  } catch (error) {
+    // Log the error and throw it
+    notification.setNotification(
+      db,
+      'ERROR',
+      `Error during template rendering of ${singleTemplatePkg.path}: ` +
+        error.message,
+      sessionId,
+      1
+    )
+    console.error(
+      `Error during template rendering of ${singleTemplatePkg.path}: `,
+      error
+    )
+    throw error
+  }
   return [
     {
       key:

src-electron/generator/template-util.js

@@ -494,7 +494,6 @@ async function ensureZclEventSdkExtensions(context, templatePackageId) {
  */
 function templatePromise(global, promise) {
   let syncPromise = makeSynchronizablePromise(promise)
-  global.promises.push(syncPromise)
   return syncPromise
 }
 /**

test/gen-matter-1.test.js

@@ -274,6 +274,25 @@ test(
         "// command: 0x0300 / 0x00 => MoveToHue, test extension: '', isLargeMessage: true"
       )
     )
+
+    // Testing promisedHandlebars when we have {{#if (promise)}} in a template
+    // Eg: {{#zcl_clusters}}
+    // {{#zcl_commands_source_server}}
+    // {{#zcl_command_arguments}}
+    // {{#if (zcl_command_arguments_count ../index)}}
+    // zcl command arguments exist for {{../name}} command. It has {{zcl_command_arguments_count ../index}} arguments
+    // {{else}}
+    // zcl command arguments do not exist for {{../name}} command.
+    // {{/if}}
+    // {{/zcl_command_arguments}}
+    // {{/zcl_commands_source_server}}
+    // {{/zcl_clusters}}
+    expect(simpleTest).toContain(
+      'zcl command arguments exist for ViewGroupResponse command. It has 5 arguments'
+    )
+    expect(simpleTest).toContain(
+      'zcl command arguments do not exist for AddSceneResponse command.'
+    )
   },
   testUtil.timeout.long()
 )

test/gen-template/matter/simple-test.zapt

@@ -42,3 +42,15 @@ Base type for {{name}} : {{baseType}}
     {{/if}}
 {{/zcl_commands}}
 
+
+{{#zcl_clusters}}
+{{#zcl_commands_source_server}}
+{{#zcl_command_arguments}}
+{{#if (zcl_command_arguments_count ../index)}}
+zcl command arguments exist for {{../name}} command. It has {{zcl_command_arguments_count ../index}} arguments
+{{else}}
+zcl command arguments do not exist for {{../name}} command.
+{{/if}}
+{{/zcl_command_arguments}}
+{{/zcl_commands_source_server}}
+{{/zcl_clusters}}