Refactor Renode and Dotnet package configurations to enhance build and packaging processes, including improved version handling and environment variable management.

Author: r-slabs

conanfile.py

@@ -1,55 +1,51 @@
 from conan import ConanFile
-from conan.tools.files import copy
+from conan.tools.files import copy, load
 import os
 
-
 class RenodeConan(ConanFile):
     name = "renode"
     license = "MIT"
-    # We are having a copy of whatever is there on Stash in github for now.
     url = "https://stash.silabs.com/projects/EMBSW/repos/renode/browse"
     description = "Antmicro's open source simulation and virtual development framework for complex embedded systems"
     topics = ("iot", "simulation", "embedded-systems", "arm", "risc-v", "x86")
     settings = "os", "arch"
-    # Copy all files from source folder to build folder
     exports_sources = "*"
     user = "silabs"
-    # At this point, we do not have a process to build renode for multiple architectures.
-    # So we are using the build_policy missing to build it for the other architectures, on the users machine.
-    build_policy = "missing"
+
+    def set_version(self):
+        version_path = os.path.join(self.recipe_folder, "tools", "version")
+        self.version = load(self, version_path).strip()
 
     def requirements(self):
         self.tool_requires("dotnet_tools/8.0.409@silabs")
         self.tool_requires("cmake/3.27.6")
 
-    def set_version(self) -> None:
-        with open(os.path.join(self.recipe_folder, "tools", "version"), "r") as f:
-            self.version = f.read().strip()
-
-    def layout(self):
-        self.folders.build = "build"
-
-    def build(self) -> None:
+    def build(self):
         if self.settings.os == "Windows":
             self.run("build.cmd", cwd=self.source_folder, shell=True)
         else:
-            self.run("dotnet --version") 
-            self.run("cmake --version")
-            self.run("chmod +x build.sh", cwd=self.source_folder)
+            self.run("dotnet --version", env="conanbuild")
+            self.run("cmake --version", env="conanbuild")
+
+            build_script = os.path.join(self.source_folder, "build.sh")
+            if not os.path.isfile(build_script):
+                raise FileNotFoundError(f"build.sh not found at {build_script}")
+            self.run(f"chmod +x {build_script}")
+
             if self.settings.arch == "armv8":
-                self.run("./build.sh --net --host-arch aarch64", cwd=self.source_folder)
+                arch = "aarch64"
             elif self.settings.arch == "x86_64":
-                self.run("./build.sh --net --host-arch x86_64", cwd=self.source_folder)
+                arch = "x86_64"
             else:
-                self.run("./build.sh --net --host-arch x86", cwd=self.source_folder)
+                arch = "x86"
 
-    def package(self) -> None:
-        # Copy all files from build folder to package folder
-        copy(self, "*", self.build_folder, self.package_folder)
+            self.run(f"{build_script} --net --host-arch {arch}", cwd=self.source_folder)
 
-        # Copy all files from current directory to package folder
-        copy(self, "*", self.source_folder, self.package_folder, keep_path=True)
+    def package(self):
+        # Copy build output
+        copy(self, "*", src=self.source_folder, dst=self.package_folder, keep_path=True)
 
-    def package_info(self) -> None:
+    def package_info(self):
+        renode_path = os.path.join(self.package_folder, ".")
         self.runenv_info.define("RENODE_HOME", self.package_folder)
-        self.runenv_info.append_path("PATH", os.path.join(self.package_folder, "renode"))
+        self.runenv_info.append_path("PATH", renode_path)

dot_net/conanfile.py

@@ -9,22 +9,10 @@ class DotnetToolsConan(ConanFile):
     url = "https://dotnet.microsoft.com/en-us/download/dotnet/8.0"
     description = ".NET 8.0 SDK"
     settings = "os", "arch"
-    package_type = "application"
     user = "silabs"
-    build_policy = "missing"
-
-
-    def layout(self):
-        self.folders.source = "."
-        self.folders.build = "build"
-        self.folders.packages = "package"
-
-    def requirements(self):
-        pass  # No dependenciesw
 
     def build(self):
-        # Download the correct SDK for the platform
-        base_url = f"https://builds.dotnet.microsoft.com/dotnet/Sdk/{self.version}/"
+        base_url = f"https://dotnetcli.azureedge.net/dotnet/Sdk/{self.version}"
         if self.settings.os == "Macos":
             if self.settings.arch == "x86_64":
                 url = f"{base_url}/dotnet-sdk-{self.version}-osx-x64.tar.gz"
@@ -51,16 +39,13 @@ def build(self):
         else:
             raise ValueError("Unsupported OS")
 
-        # Use strip_root=True for tar.gz, but False for zip files to avoid ConanException
-        if url.endswith(".zip"):
-            get(self, url, strip_root=False, destination=self.build_folder)
-        else:
-            get(self, url, strip_root=True, destination=self.build_folder)
+        # Always use strip_root=False for .NET SDK archives
+        get(self, url, strip_root=False, keep_permissions=True)
 
     def package(self):
-        # Copy everything to the package folder
-        copy(self, "*", src=self.build_folder, dst=os.path.join(self.package_folder, "."))
+        copy(self, "*", src=self.source_folder, dst=self.package_folder)
 
     def package_info(self):
-        self.buildenv_info.append_path("PATH", os.path.join(self.package_folder, "."))
-        self.runenv_info.append_path("PATH", os.path.join(self.package_folder, "."))
+        bin_path = os.path.join(self.package_folder, ".")
+        self.buildenv_info.append_path("PATH", bin_path)
+        self.runenv_info.append_path("PATH", bin_path)

dot_net/test_package/conanfile.py

@@ -4,15 +4,15 @@
 
 
 class DotnetTestPkg(ConanFile):
-    # Install dotnet with Conan and run the version command to make sure it boots.
-    settings = ["os"]
+    settings = "os", "arch"
+    test_type = "explicit"  # Explicitly define this is a test package
 
     def requirements(self):
-        # This is a test package, so it must depend on the package under test.
+        # This test package depends on the package under test
         self.requires(self.tested_reference_str)
 
     def test(self):
-        # Execute dotnet and make sure it runs.
         if can_run(self):
-            self.run(f'dotnet --version', env="conanbuild")
-            self.run(f'dotnet --help', env="conanbuild")
+            self.output.info("Testing dotnet installation...")
+            self.run("dotnet --version", env="conanrun")
+            self.run("dotnet --help", env="conanrun")

test_package/conanfile.py

@@ -6,16 +6,17 @@
 from conan.tools.files import copy
 
 class TestRenodePackage(ConanFile):
-    settings = ["os"]
+    settings = "os", "arch"
+    test_type = "explicit"
 
     def requirements(self):
         self.requires(self.tested_reference_str)
         self.requires("dotnet_tools/8.0.409@silabs")
 
     def test(self):
-        renode_pkg = self.dependencies["renode"].package_folder
         if can_run(self):
+            renode_pkg = self.dependencies["renode"].package_folder
             self.run("echo $PATH", env="conanrun")
             self.run("which dotnet", env="conanrun")
-            self.run("./renode-test --help", env="conanrun", cwd=renode_pkg)
-            self.run("./renode-test tests/unit-tests/RenodeTests/RenodeTests_NET.csproj", env="conanrun", cwd=renode_pkg)
+            self.run("renode-test --help", env="conanrun", cwd=renode_pkg)
+            self.run("renode-test tests/unit-tests/RenodeTests/RenodeTests_NET.csproj", env="conanrun", cwd=renode_pkg)