tooling: Migrate to Conan 2.0 compatible recipes and build files

Conan 2.0 brings important benefits that we will want to be able to take
advantage of as soon as possible. To this end this commits already
performs some of the most important steps by migrating the recipes and
build tooling.

This already brings some gains:

- CMake `find_package` can be used instead of using non-portable
  CONAN_PKG.
- We can package external tools with Conan without needing to
  patch the CMake files.
- It should be easier to integrate Conan workspaces going forward.

Other changes:
- Conan minimum version set to 1.52
- Conan recipes use the APIs from the `conan` instead of the `conans`
  Python library. These are better structured and are 2.0 compatible.

Author: cassava

Makefile.package

@@ -52,7 +52,7 @@ LOCKFILE_OPTION  :=
 CLEAN_SOURCE_DIR := false
 BUILD_IN_SOURCE  := true
 BUILD_DIR        := build
-BUILD_CONANINFO  := ${BUILD_DIR}/conanbuildinfo.cmake
+BUILD_CONANINFO  := ${BUILD_DIR}/conanbuildinfo.txt
 BUILD_CMAKECACHE := ${BUILD_DIR}/CMakeCache.txt
 BUILD_LOCKFILE   := ${BUILD_DIR}/conan.lock
 BUILD_LAYOUT     := ${PROJECT_ROOT}/.conan-layout.ini
@@ -395,7 +395,7 @@ else
 all: ${BUILD_CONANINFO} | ${SOURCE_DIR}
 	# Build the package in-source.
 	#
-	conan build . --source-folder="${SOURCE_DIR}" --build-folder="${BUILD_DIR}"
+	conan build . --source-folder="${SOURCE_DIR}" --install-folder="${BUILD_DIR}"
 
 .PHONY: conan
 conan: ${BUILD_CONANINFO}
@@ -448,5 +448,5 @@ ${BUILD_CONANINFO}: ${SOURCE_CONANFILE} ${BUILD_LOCKFILE}
 ${BUILD_CMAKECACHE}: ${SOURCE_CMAKELISTS} ${BUILD_CONANINFO}
 	# Configure in-source build with CMake.
 	#
-	conan build --configure . --source-folder="${SOURCE_DIR}" --build-folder="${BUILD_DIR}"
+	conan build --configure . --source-folder="${SOURCE_DIR}" --install-folder="${BUILD_DIR}"
 endif

cli/conanfile.py

@@ -3,8 +3,10 @@
 
 from pathlib import Path
 
-from conans import ConanFile, tools
-from conan.tools.env import Environment
+from conan import ConanFile
+from conan.tools import files, scm, env
+
+required_conan_version = ">=1.52.0"
 
 class Base(object):
     settings = "os", "compiler", "build_type", "arch"
@@ -14,10 +16,10 @@ def generate(self):
         if "cloe_launch_env" not in dir(self):
             return
 
-        env = Environment()
+        export = env.Environment()
         for k, v in self.cloe_launch_env.items():
-            env.define(k, str(v))
-        env_vars = env.vars(self)
+            export.define(k, str(v))
+        env_vars = export.vars(self)
 
         # Raw environment variables
         env_file = Path(self.generators_folder) / "environment_cloe_launch.sh.env"
@@ -33,8 +35,8 @@ def project_version(self, version_path):
         if version_path:
             version_file = Path(self.recipe_folder) / version_path
             if version_file.exists():
-                return tools.load(version_file).strip()
-        git = tools.Git(folder=self.recipe_folder)
+                return files.load(self, version_file).strip()
+        git = scm.Git(self, self.recipe_folder)
         return git.run("describe --dirty=-dirty")[1:]
 
 
@@ -47,7 +49,7 @@ class CloeLaunchProfile(ConanFile):
     channel = "develop"
 
     def set_version(self):
-        for line in tools.load("setup.py").split("\n"):
+        for line in files.load(self, "setup.py").split("\n"):
             if not line.strip().startswith("version="):
                 continue
             self.version = line.strip().split("=")[1].strip('",')

conanfile.py

@@ -2,7 +2,11 @@
 # pylint: skip-file
 
 from pathlib import Path
-from conans import CMake, ConanFile, RunEnvironment, tools
+
+from conan import ConanFile
+from conan.tools import cmake, files, scm
+
+required_conan_version = ">=1.52.0"
 
 
 class Cloe(ConanFile):
@@ -27,17 +31,14 @@ class Cloe(ConanFile):
 
         "cloe-engine:server": True,
     }
-    generators = "cmake"
     no_copy_source = True
 
-    _cmake = None
-
     def set_version(self):
         version_file = Path(self.recipe_folder) / "VERSION"
         if version_file.exists():
-            self.version = tools.load(version_file).strip()
+            self.version = files.load(self, version_file).strip()
         else:
-            git = tools.Git(folder=self.recipe_folder)
+            git = scm.Git(self, self.recipe_folder)
             self.version = git.run("describe --dirty=-dirty")[1:]
 
     def requirements(self):
@@ -69,28 +70,5 @@ def cloe_requires(dep):
         self.requires("incbin/cci.20211107", override=True),
         self.requires(f"boost/{boost_version}", override=True)
 
-    def _configure_cmake(self):
-        if self._cmake:
-            return self._cmake
-        self._cmake = CMake(self)
-        self._cmake.definitions["CMAKE_EXPORT_COMPILE_COMMANDS"] = True
-        self._cmake.definitions["TargetLintingExtended"] = self.options.pedantic
-        self._cmake.configure()
-        return self._cmake
-
-    def build(self):
-        # This build is for a workspace build. See: conanws.yml
-        if not self.in_local_cache:
-            cmake = self._configure_cmake()
-            cmake.build()
-            with tools.environment_append(RunEnvironment(self).vars):
-                cmake.test()
-
-    def package(self):
-        # This build is for a workspace build. See: conanws.yml
-        if not self.in_local_cache:
-            cmake = self._configure_cmake()
-            cmake.install()
-
     def package_id(self):
         del self.info.options.pedantic

docs/develop/integrating-a-controller.rst

@@ -11,25 +11,37 @@ in your plugin's root directory containing the following:
 .. code-block:: txt
 
    [requires]
-   cloe/0.17.0
+   cloe/0.20.0@cloe/develop
+
+   [generators]
+   CMakeDeps
+   CMakeToolchain
+
+   [layout]
+   cmake_layout
 
 It states the version of the Cloe package to use. All dependencies of Cloe will
 be inherited and should not be re-stated unless you explicitly want to use a
 particular version of a dependency here.
 
-Now run ``conan install . --install-folder build``. This ensures that Cloe and
-its dependencies are cached and will create a file called
-``conanbuildinfo.cmake`` in the ``build`` folder. Include this file in your
-CMakeLists.txt (we assume you use CMake for your plugin project) like:
+Now run ``conan install . --build=missing --install-folder=build``.
+This ensures that Cloe and its dependencies are cached and will create a
+toolchain file called ``conan_toolchain.cmake`` in the ``build/generators``
+folder. Include this file from the command line when calling CMake
+and then ``find_package`` your requirements like:
 
 .. code-block::
 
-   include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
-   conan_basic_setup(TARGETS NO_OUTPUT_DIRS)
+   find_package(cloe-runtime REQUIRED)
+   find_package(cloe-models REQUIRED)
 
-Now you can refer to cloe as a dependency library in your
-``target_link_libararies`` statement like ``CONAN_PKG::cloe``.
+See the example projects in ``fable/examples`` for some examples of how Conan
+is used. If any of this is new to you and you find yourself working with Conan,
+then it is also highly recommended to take a Conan course from JFrog (free
+of charge) to get familiar with Conan.
 
+Now you can refer to cloe as a dependency library in your
+``target_link_libararies`` statement like ``cloe::runtime``.
 
 .. todo:: Write a section on how to specify a specific version of Cloe.
    There are multiple use-cases here:

engine/CMakeLists.txt

@@ -6,14 +6,14 @@ set(target cloe-engine)
 set(output cloe-engine)
 set(libstack cloe-stack)
 
-option(WithServer "Enable integrated server component?" ON)
-
-# Conan / Editor -----------------------------------------------------
-include(${CMAKE_CURRENT_BINARY_DIR}/conanbuildinfo.cmake)
-conan_basic_setup(TARGETS)
+find_package(cloe-runtime REQUIRED)
+find_package(cloe-models REQUIRED)
+find_package(fable REQUIRED)
+find_package(Boost REQUIRED)
+find_package(CLI11 REQUIRED)
 
 include(TargetLinting)
-include(CTest)
+include(GNUInstallDirs)
 
 # Compiler definitions
 string(TIMESTAMP CLOE_ENGINE_TIMESTAMP "%Y-%m-%d")
@@ -35,13 +35,15 @@ target_include_directories(${libstack}
 )
 target_link_libraries(${libstack}
   PUBLIC
-    CONAN_PKG::cloe-runtime
-    CONAN_PKG::fable
+    cloe::runtime
+    fable::fable
     pthread
     dl
 )
 
+include(CTest)
 if(BUILD_TESTING)
+    find_package(GTest REQUIRED)
     include(GoogleTest)
 
     set(test-libstack test-${libstack})
@@ -53,9 +55,10 @@ if(BUILD_TESTING)
         CXX_STANDARD_REQUIRED ON
     )
     target_link_libraries(${test-libstack}
-        CONAN_PKG::gtest
-        CONAN_PKG::boost
-        CONAN_PKG::cloe-models
+        GTest::gtest
+        GTest::gtest_main
+        Boost::boost
+        cloe::models
         ${libstack}
     )
     gtest_add_tests(TARGET ${test-libstack})
@@ -90,20 +93,22 @@ target_include_directories(${target}
 )
 target_link_libraries(${target}
   PRIVATE
-    CONAN_PKG::cli11
-    CONAN_PKG::cloe-models
+    CLI11::CLI11
+    cloe::models
     ${libstack}
 )
 
-if(${WithServer})
+option(CLOE_ENGINE_WITH_SERVER "Enable integrated server component?" ON)
+if(CLOE_ENGINE_WITH_SERVER)
   message(STATUS "-> Enable server component")
+  find_package(cloe-oak REQUIRED)
   target_sources(${target}
     PRIVATE
       src/server.cpp
   )
   target_link_libraries(${target}
     PRIVATE
-      CONAN_PKG::cloe-oak
+      cloe::oak
   )
   target_compile_definitions(${target}
     PRIVATE
@@ -122,7 +127,6 @@ else()
 endif()
 
 # Installation -------------------------------------------------------
-include(GNUInstallDirs)
 install(TARGETS ${target}
     RUNTIME
         DESTINATION ${CMAKE_INSTALL_BINDIR}

engine/conanfile.py

@@ -3,8 +3,11 @@
 
 import os
 from pathlib import Path
-from conans import CMake, ConanFile, RunEnvironment, tools
 
+from conan import ConanFile
+from conan.tools import cmake, env, files, scm
+
+required_conan_version = ">=1.52.0"
 
 class CloeEngine(ConanFile):
     name = "cloe-engine"
@@ -29,22 +32,20 @@ class CloeEngine(ConanFile):
 
         "fable:allow_comments": True,
     }
-    generators = "cmake"
+    generators = "CMakeDeps", "VirtualRunEnv"
     no_copy_source = True
     exports_sources = [
         "src/*",
         "webui/*",
         "CMakeLists.txt",
     ]
 
-    _cmake = None
-
     def set_version(self):
         version_file = Path(self.recipe_folder) / "../VERSION"
         if version_file.exists():
-            self.version = tools.load(version_file).strip()
+            self.version = files.load(self, version_file).strip()
         else:
-            git = tools.Git(folder=self.recipe_folder)
+            git = scm.Git(self, self.recipe_folder)
             self.version = git.run("describe --dirty=-dirty")[1:]
 
     def requirements(self):
@@ -62,32 +63,36 @@ def requirements(self):
     def build_requirements(self):
         self.test_requires("gtest/[~1.10]")
 
-    def _configure_cmake(self):
-        if self._cmake:
-            return self._cmake
-        self._cmake = CMake(self)
-        self._cmake.definitions["CMAKE_EXPORT_COMPILE_COMMANDS"] = True
-        self._cmake.definitions["WithServer"] = self.options.server
-        self._cmake.definitions["TargetLintingExtended"] = self.options.pedantic
-        self._cmake.definitions["CLOE_PROJECT_VERSION"] = self.version
-        self._cmake.configure()
-        return self._cmake
+    def layout(self):
+        cmake.cmake_layout(self)
+
+    def generate(self):
+        tc = cmake.CMakeToolchain(self)
+        tc.cache_variables["CMAKE_EXPORT_COMPILE_COMMANDS"] = True
+        tc.cache_variables["CLOE_PROJECT_VERSION"] = self.version
+        tc.cache_variables["CLOE_ENGINE_WITH_SERVER"] = self.options.server
+        tc.cache_variables["TargetLintingExtended"] = self.options.pedantic
+        tc.generate()
 
     def build(self):
-        cmake = self._configure_cmake()
-        cmake.build()
-        with tools.environment_append(RunEnvironment(self).vars):
-            cmake.test()
+        cm = cmake.CMake(self)
+        cm.configure()
+        cm.build()
+        cm.test()
 
     def package(self):
-        cmake = self._configure_cmake()
-        cmake.install()
+        cm = cmake.CMake(self)
+        cm.install()
 
     def package_id(self):
         self.info.requires["boost"].full_package_mode()
         del self.info.options.pedantic
 
     def package_info(self):
+        self.cpp_info.set_property("cmake_find_mode", "both")
+        self.cpp_info.set_property("cmake_file_name", "cloe-engine")
+        self.cpp_info.set_property("cmake_target_name", "cloe::engine")
+        self.cpp_info.set_property("pkg_config_name", "cloe-engine")
         if self.settings.os == "Linux":
             self.cpp_info.system_libs.append("pthread")
             self.cpp_info.system_libs.append("dl")