Standalone version fixes and improvements

Author: pijaro

.gitignore

@@ -3,5 +3,6 @@ log
 build
 .idea
 src/ros2cs
+**/metadata*.xml
 src/Ros2ForUnity/Plugins
 !src/Ros2ForUnity/Plugins/.gitkeep

build.ps1

@@ -34,6 +34,13 @@ if($clean_install) {
     Write-Host "Cleaning install directory..." -ForegroundColor White
     Remove-Item -Path "$scriptPath\install" -Force -Recurse -ErrorAction Ignore
 }
+
+if($standalone) {}
+  & "python3 $SCRIPTPATH\src\scripts\metadata_generator.py" --standalone
+} else {
+  & "python3 $SCRIPTPATH\src\scripts\metadata_generator.py"
+}
+
 & "$scriptPath\src\ros2cs\build.ps1" @options
 if($?) {
     md -Force $scriptPath\install\asset | Out-Null
@@ -42,6 +49,9 @@ if($?) {
     $plugin_path=Join-Path -Path $scriptPath -ChildPath "\install\asset\Ros2ForUnity\Plugins\"
     Write-Host "Deploying build to $plugin_path" -ForegroundColor Green
     & "$scriptPath\deploy_unity_plugins.ps1" $plugin_path
+
+    Copy-Item -Path $scriptPath\src\Ros2ForUnity\metadata_ros2cs.xml -Destination $scriptPath\install\asset\Ros2ForUnity\Plugins\Linux\x86_64\
+    Copy-Item -Path $scriptPath\src\Ros2ForUnity\metadata_ros2cs.xml -Destination $scriptPath\install\asset\Ros2ForUnity\Plugins\
 } else {
     Write-Host "Ros2cs build failed!" -ForegroundColor Red
     exit 1

build.sh

@@ -55,9 +55,18 @@ if [ $CLEAN_INSTALL == 1 ]; then
     echo "Cleaning install directory..."
     rm -rf $SCRIPTPATH/install/*
 fi
+
+if [ $STANDALONE == 1 ]; then
+  python3 $SCRIPTPATH/src/scripts/metadata_generator.py --standalone
+else
+  python3 $SCRIPTPATH/src/scripts/metadata_generator.py
+fi
+
 if $SCRIPTPATH/src/ros2cs/build.sh $OPTIONS; then
     mkdir -p $SCRIPTPATH/install/asset && cp -R $SCRIPTPATH/src/Ros2ForUnity $SCRIPTPATH/install/asset/
     $SCRIPTPATH/deploy_unity_plugins.sh $SCRIPTPATH/install/asset/Ros2ForUnity/Plugins/
+    cp $SCRIPTPATH/src/Ros2ForUnity/metadata_ros2cs.xml $SCRIPTPATH/install/asset/Ros2ForUnity/Plugins/Linux/x86_64/metadata_ros2cs.xml
+    cp $SCRIPTPATH/src/Ros2ForUnity/metadata_ros2cs.xml $SCRIPTPATH/install/asset/Ros2ForUnity/Plugins/metadata_ros2cs.xml
 else
     echo "Ros2cs build failed!"
     exit 1

src/Ros2ForUnity/Scripts/ROS2ForUnity.cs

@@ -17,6 +17,7 @@
 using System.Collections.Generic;
 using UnityEngine;
 using UnityEditor;
+using System.Xml;
 
 namespace ROS2
 {
@@ -28,6 +29,8 @@ internal class ROS2ForUnity
 {
     private static bool isInitialized = false;
     private static string ros2ForUnityAssetFolderName = "Ros2ForUnity";
+    private XmlDocument ros2csMetadata = new XmlDocument();
+    private XmlDocument ros2ForUnityMetadata = new XmlDocument();
 
     enum Platform
     {
@@ -80,7 +83,7 @@ private string GetEnvPathVariableValue()
         return Environment.GetEnvironmentVariable(GetEnvPathVariableName());
     }
 
-    private string GetPluginPath()
+    private string GetRos2ForUnityPath()
     {
         char separator = Path.DirectorySeparatorChar;
         string appDataPath = Application.dataPath;
@@ -89,6 +92,14 @@ private string GetPluginPath()
         if (InEditor()) {
             pluginPath += separator + ros2ForUnityAssetFolderName;
         }
+        return pluginPath; 
+    }
+
+    private string GetPluginPath()
+    {
+        char separator = Path.DirectorySeparatorChar;
+        string ros2ForUnityPath = GetRos2ForUnityPath();
+        string pluginPath = ros2ForUnityPath;
 
         pluginPath += separator + "Plugins";
 
@@ -116,7 +127,7 @@ private string GetPluginPath()
     /// Note that on Linux, LD_LIBRARY_PATH as used for dlopen() is determined on process start and this change won't
     /// affect it. Ros2 looks for rmw implementation based on this variable (independently) and the change
     /// is effective for this process, however rmw implementation's dependencies itself are loaded by dynamic linker 
-    /// anyway so setting  it for Linux is pointless.
+    /// anyway so setting it for Linux is pointless.
     /// </description>
     private void SetEnvPathVariable()
     {
@@ -132,16 +143,69 @@ private void SetEnvPathVariable()
         Environment.SetEnvironmentVariable(GetEnvPathVariableName(), pluginPath + envPathSep + currentPath);
     }
 
+    public bool IsStandalone() {
+        return Convert.ToBoolean(Convert.ToInt16(GetMetadataValue(ros2csMetadata, "/ros2cs/standalone")));
+    }
+
+    public string GetROSVersion()
+    {
+        string ros2SourcedCodename = GetROSVersionSourced();
+        string ros2FromRos4UMetadata = GetMetadataValue(ros2ForUnityMetadata, "/ros2_for_unity/ros2");
+
+        //  Sourced ROS2 libs takes priority
+        if (string.IsNullOrEmpty(ros2SourcedCodename)) {
+            return ros2FromRos4UMetadata;
+        }
+        
+        return ros2SourcedCodename;
+    }
+
+    /// <summary>
+    /// Checks if both ros2cs and ros2-for-unity were build for the same ros version as well as
+    /// the current sourced ros version matches ros2cs binaries.
+    /// </summary>
+    public void CheckIntegrity()
+    {
+        string ros2SourcedCodename = GetROSVersionSourced();
+        string ros2FromRos2csMetadata = GetMetadataValue(ros2csMetadata, "/ros2cs/ros2");
+        string ros2FromRos4UMetadata = GetMetadataValue(ros2ForUnityMetadata, "/ros2_for_unity/ros2");
+
+        if (ros2FromRos4UMetadata != ros2FromRos2csMetadata) {
+            Debug.LogError(
+                "ROS2 versions in 'ros2cs' and 'ros2-for-unity' metadata files are not the same. " +
+                "This is caused by mixing versions/builds. Plugin might not work correctly."
+            );
+        }
+
+        if(!IsStandalone() && ros2SourcedCodename != ros2FromRos2csMetadata) {
+            Debug.LogError(
+                "ROS2 version in 'ros2cs' metadata doesn't match currently sourced version. " +
+                "This is caused by mixing versions/builds. Plugin might not work correctly."
+            );
+        }
+
+        if (IsStandalone() && !string.IsNullOrEmpty(ros2SourcedCodename)) {
+            Debug.LogError(
+                "You should not source ROS2 in 'ros2-for-unity' standalone build. " +
+                "Plugin might not work correctly."
+            );
+        }
+    }
+
+    public string GetROSVersionSourced()
+    {
+        return Environment.GetEnvironmentVariable("ROS_DISTRO");
+    }
+
     /// <summary>
     /// Check if the ros version is supported, only applicable to non-standalone plugin versions
     /// (i. e. without ros2 libraries included in the plugin).
     /// </summary>
-    private string CheckROSVersionSourced()
+    private void CheckROSSupport(string ros2Codename)
     {
-        string currentVersion = Environment.GetEnvironmentVariable("ROS_DISTRO");
         List<string> supportedVersions = new List<string>() { "foxy", "galactic" };
         var supportedVersionsString = String.Join(", ", supportedVersions);
-        if (string.IsNullOrEmpty(currentVersion))
+        if (string.IsNullOrEmpty(ros2Codename))
         {
             string errMessage = "No ROS environment sourced. You need to source your ROS2 " + supportedVersionsString
               + " environment before launching Unity (ROS_DISTRO env variable not found)";
@@ -155,9 +219,9 @@ private string CheckROSVersionSourced()
 #endif
         }
 
-        if (!supportedVersions.Contains(currentVersion))
+        if (!supportedVersions.Contains(ros2Codename))
         {
-            string errMessage = "Currently sourced ROS version differs from supported one. Sourced: " + currentVersion
+            string errMessage = "Currently sourced ROS version differs from supported one. Sourced: " + ros2Codename
               + ", supported: " + supportedVersionsString + ".";
             Debug.LogError(errMessage);
 #if UNITY_EDITOR
@@ -168,8 +232,6 @@ private string CheckROSVersionSourced()
             Application.Quit(ROS_BAD_VERSION_CODE);
 #endif
         }
-        Debug.Log("Running with a supported ROS 2 version: " + currentVersion);
-        return currentVersion;
     }
 
     private void RegisterCtrlCHandler()
@@ -192,28 +254,63 @@ private void ConnectLoggers()
         Ros2csLogger.LogLevel = LogLevel.WARNING;
     }
 
+    private string GetMetadataValue(XmlDocument doc, string valuePath)
+    {
+        return doc.DocumentElement.SelectSingleNode(valuePath).InnerText;
+    }
+
+    private void LoadMetadata() 
+    {
+        char separator = Path.DirectorySeparatorChar;
+        try
+        {
+            ros2csMetadata.Load(GetPluginPath() + separator + "metadata_ros2cs.xml");
+            ros2ForUnityMetadata.Load(GetRos2ForUnityPath() + separator + "metadata_ros2_for_unity.xml");
+        }
+        catch (System.IO.FileNotFoundException)
+        {
+            var errMessage = "Could not find metadata files.";
+#if UNITY_EDITOR
+            EditorApplication.isPlaying = false;
+            throw new System.IO.FileNotFoundException(errMessage);
+#else
+            const int NO_METADATA = 1;
+            Application.Quit(NO_METADATA);
+#endif
+        }
+    }
+
     internal ROS2ForUnity()
     {
-        // TODO: Find a way to determine whether we run standalone build
+        // Load metadata
+        LoadMetadata();
+        string currentRos2Version = GetROSVersion();
+        string standalone = IsStandalone() ? "standalone" : "non-standalone";
+
+        // Self checks
+        CheckROSSupport(currentRos2Version);
+        CheckIntegrity();
+
+        // Library loading
         if (GetOS() == Platform.Windows) {
             // Windows version can run standalone, modifies PATH to ensure all plugins visibility
             SetEnvPathVariable();
         } else {
-            // Linux version needs to have ros2 sourced, which is checked here. It also loads plugins by absolute path
-            // since LD_LIBRARY_PATH cannot be set dynamically within the process for dlopen() which is used under the hood.
-            // Since libraries are built with -rpath=".", dependencies will be correcly located within plugins directory.
-            // For foxy, it is also necessary to use modified version of librcpputils to resolve custom msgs packages.
-            string currentRosVersion = CheckROSVersionSourced();
+            // For foxy, it is necessary to use modified version of librcpputils to resolve custom msgs packages.
             ROS2.GlobalVariables.absolutePath = GetPluginPath() + "/";
-            if (currentRosVersion == "foxy") {
+            if (currentRos2Version == "foxy") {
                 ROS2.GlobalVariables.preloadLibrary = true;
                 ROS2.GlobalVariables.preloadLibraryName = "librcpputils.so";
             }
         }
+
+        // Initialize
         ConnectLoggers();
         Ros2cs.Init();
         RegisterCtrlCHandler();
 
+        Ros2csLogger.GetInstance().LogInfo("ROS2 version: " + currentRos2Version + ". Build type: " + standalone);
+
 #if UNITY_EDITOR
         EditorApplication.playModeStateChanged += this.EditorPlayStateChanged;
         EditorApplication.quitting += this.DestroyROS2ForUnity;

src/scripts/metadata_generator.py

@@ -0,0 +1,72 @@
+# Copyright 2019-2022 Robotec.ai.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import xml.etree.ElementTree as ET
+from xml.dom import minidom
+import subprocess
+import pathlib
+
+parser = argparse.ArgumentParser(description='Generate metadata file for ros2-for-unity.')
+parser.add_argument('--standalone', action='store_true', help='is a standalone build')
+args = parser.parse_args()
+
+def get_git_commit(working_directory) -> str:
+    return subprocess.check_output(['git', 'rev-parse', 'HEAD'], cwd=working_directory).decode('ascii').strip()
+
+def get_git_description(working_directory) -> str:
+    return subprocess.check_output(['git', 'describe', '--tags', '--always'], cwd=working_directory).decode('ascii').strip()
+
+def get_commit_date(working_directory) -> str:
+    return subprocess.check_output(['git', 'show', '-s', '--format=%ci'], cwd=working_directory).decode('ascii').strip()
+
+def get_git_abbrev(working_directory) -> str:
+    return subprocess.check_output(['git', 'rev-parse', '--abbrev-ref', 'HEAD'], cwd=working_directory).decode('ascii').strip()
+
+def get_ros2_for_unity_root_path() -> pathlib.Path:
+    return pathlib.Path(__file__).parents[2]
+
+def get_ros2_for_unity_path() -> pathlib.Path:
+    return pathlib.Path(__file__).parents[1].joinpath("Ros2ForUnity")
+
+def get_ros2cs_path() -> pathlib.Path:
+    return pathlib.Path(__file__).parents[1].joinpath("ros2cs")
+
+def get_ros2_path() -> pathlib.Path:
+    return get_ros2cs_path().joinpath("src").joinpath("ros2").joinpath("rcl_interfaces")
+
+ros2_for_unity = ET.Element("ros2_for_unity")
+ET.SubElement(ros2_for_unity, "ros2").text = get_git_abbrev(get_ros2_path())
+ros2_for_unity_version = ET.SubElement(ros2_for_unity, "version")
+ET.SubElement(ros2_for_unity_version, "sha").text = get_git_commit(get_ros2_for_unity_root_path())
+ET.SubElement(ros2_for_unity_version, "desc").text = get_git_description(get_ros2_for_unity_root_path())
+ET.SubElement(ros2_for_unity_version, "date").text = get_commit_date(get_ros2_for_unity_root_path())
+
+ros2_cs = ET.Element("ros2cs")
+ET.SubElement(ros2_cs, "ros2").text = get_git_abbrev(get_ros2_path())
+ros2_cs_version = ET.SubElement(ros2_cs, "version")
+ET.SubElement(ros2_cs_version, "sha").text = get_git_commit(get_ros2cs_path())
+ET.SubElement(ros2_cs_version, "desc").text = get_git_description(get_ros2cs_path())
+ET.SubElement(ros2_cs_version, "date").text = get_commit_date(get_ros2cs_path())
+ET.SubElement(ros2_cs, "standalone").text = str(int(args.standalone))
+
+rf2u_xmlstr = minidom.parseString(ET.tostring(ros2_for_unity)).toprettyxml(indent="   ")
+metadata_rf2u_file = get_ros2_for_unity_path().joinpath("metadata_ros2_for_unity.xml")
+with open(str(metadata_rf2u_file), "w") as f:
+    f.write(rf2u_xmlstr)
+    
+r2cs_xmlstr = minidom.parseString(ET.tostring(ros2_cs)).toprettyxml(indent="   ")
+metadata_r2cs_file = get_ros2_for_unity_path().joinpath("metadata_ros2cs.xml")
+with open(str(metadata_r2cs_file), "w") as f:
+    f.write(r2cs_xmlstr)