Generate missing messages at runtime

Author: minggangw

lib/interface_loader.js

@@ -90,6 +90,66 @@ let interfaceLoader = {
     return pkg;
   },
 
+  _searchAndGenerateInterface(packageName, type, messageName, filePath) {
+    // Check if it's a valid package
+    for (const pkgPath of generator.getInstalledPackagePaths()) {
+      if (pkgPath.includes('ros2-linux')) {
+        continue;
+      }
+
+      // Recursively search for files named messageName.* under pkgPath/
+      if (fs.existsSync(pkgPath)) {
+        // Recursive function to search for files
+        function searchForFile(dir) {
+          try {
+            const items = fs.readdirSync(dir, { withFileTypes: true });
+            for (const item of items) {
+              const fullPath = path.join(dir, item.name);
+
+              if (item.isFile()) {
+                const baseName = path.parse(item.name).name;
+                // Check if the base filename matches messageName
+                if (baseName === messageName) {
+                  return fullPath;
+                }
+              } else if (item.isDirectory()) {
+                // Recursively search subdirectories
+                const result = searchForFile(fullPath);
+                if (result) {
+                  return result;
+                }
+              }
+            }
+          } catch (err) {
+            // Skip directories we can't read
+            console.log('Error reading directory:', dir, err.message);
+          }
+          return null;
+        }
+
+        const foundFilePath = searchForFile(
+          path.join(pkgPath, 'share', packageName)
+        );
+        if (foundFilePath && foundFilePath.length > 0) {
+          // Use worker thread to generate interfaces synchronously
+          try {
+            generator.generateInPathSyncWorker(pkgPath);
+            // Now try to load the interface again from the generated files
+            if (fs.existsSync(filePath)) {
+              return require(filePath);
+            }
+          } catch (err) {
+            console.error('Error in interface generation:', err);
+          }
+        } else {
+          throw new Error(
+            `The message required does not exist: ${packageName}, ${type}, ${messageName} at ${generator.generatedRoot}`
+          );
+        }
+      }
+    }
+  },
+
   loadInterface(packageName, type, messageName) {
     if (arguments.length === 1) {
       const type = arguments[0];
@@ -110,6 +170,13 @@ let interfaceLoader = {
 
       if (fs.existsSync(filePath)) {
         return require(filePath);
+      } else {
+        return this._searchAndGenerateInterface(
+          packageName,
+          type,
+          messageName,
+          filePath
+        );
       }
     }
     throw new Error(

rosidl_gen/index.js

@@ -19,6 +19,7 @@ const generateJSStructFromIDL = require('./idl_generator.js');
 const packages = require('./packages.js');
 const path = require('path');
 const idlConvertor = require('../rosidl_convertor/idl_convertor.js');
+const { Worker } = require('worker_threads');
 const generatedRoot = path.join(__dirname, '../generated/');
 const serviceMsgPath = path.join(generatedRoot, 'srv_msg');
 const idlPath = path.join(generatedRoot, 'share');
@@ -53,6 +54,35 @@ async function generateInPath(path) {
   );
 }
 
+function generateInPathSyncWorker(targetPath) {
+  try {
+    // Use child_process.spawnSync for truly synchronous execution
+    const result = require('child_process').spawnSync(
+      'node',
+      [path.join(__dirname, 'generate-worker.js')],
+      {
+        env: { ...process.env, WORKER_TARGET_PATH: targetPath },
+        encoding: 'utf8',
+        timeout: 30000,
+      }
+    );
+
+    if (result.error) {
+      throw result.error;
+    }
+
+    if (result.status !== 0) {
+      throw new Error(
+        `Worker process exited with code ${result.status}. stderr: ${result.stderr}`
+      );
+    }
+
+    return result.stdout;
+  } catch (error) {
+    throw error;
+  }
+}
+
 async function generateAll(forcedGenerating) {
   // If we want to create the JavaScript files compulsively (|forcedGenerating| equals to true)
   // or the JavaScript files have not been created (|exist| equals to false),
@@ -86,7 +116,9 @@ const generator = {
 
   generateAll,
   generateInPath,
+  generateInPathSyncWorker,
   generatedRoot,
+  getInstalledPackagePaths,
 };
 
 module.exports = generator;

test/overlay_test_ws/geometry_msgs/CMakeLists.txt

@@ -15,6 +15,7 @@ find_package(rosidl_default_generators REQUIRED)
 
 rosidl_generate_interfaces(${PROJECT_NAME}
   "msg/Point.msg"
+  "msg/Testing.msg"
 )
 
 ament_package()

test/overlay_test_ws/geometry_msgs/msg/Testing.msg

@@ -0,0 +1,5 @@
+# This contains the position of a point in free space
+float64 x
+float64 y
+float64 z
+string data

test/overlay_test_ws/install/geometry_msgs/share/geometry_msgs/msg/Testing.msg

@@ -0,0 +1,5 @@
+# This contains the position of a point in free space
+float64 x
+float64 y
+float64 z
+string data

test/test-rosidl-message-generator.js

@@ -17,6 +17,7 @@
 const assert = require('assert');
 const os = require('os');
 const rclnodejs = require('../index.js');
+const path = require('path');
 
 describe('ROSIDL Node.js message generator test suite', function () {
   before(function () {
@@ -220,4 +221,27 @@ describe('ROSIDL Node.js message generator test suite', function () {
     assert.equal(array.size, 6);
     assert.equal(array.capacity, 6);
   });
+
+  it('Generate message at runtime', function () {
+    const amentPrefixPathOriginal = process.env.AMENT_PREFIX_PATH;
+    const customizeMsgPath = path.join(
+      __dirname,
+      'overlay_test_ws',
+      'geometry_msgs',
+      'install',
+      'geometry_msgs'
+    );
+    process.env.AMENT_PREFIX_PATH += path.delimiter;
+    process.env.AMENT_PREFIX_PATH += customizeMsgPath;
+    console.log(process.env.AMENT_PREFIX_PATH);
+    assert.doesNotThrow(() => {
+      const Testing = rclnodejs.require('geometry_msgs/msg/Testing');
+      console.log(Testing);
+      const t = new Testing();
+      assert.equal(typeof t, 'object');
+      assert.equal(typeof t.x, 'number');
+      assert.equal(typeof t.data, 'string');
+    }, 'This function should not throw');
+    process.env.AMENT_PREFIX_PATH = amentPrefixPathOriginal;
+  });
 });