Prepare the MeVisLab thirdparty libraries for the 4.0.0 release

Note that the required Conan version is now 2.2

Author: usiems

README.md

@@ -2,99 +2,87 @@
 
 Recipes for MeVisLab Thirdparty packages
 
-The `recipes` directory contains all recipes. The overall build order is currently defined in the `build_configuratuion.yml`.
+The `recipes` directory contains all recipes. The overall build order is currently defined in the `build_configuration.yml`.
 
 ## Local package development
 
 ### Preconditions
 
-First of all we need [Python >=3.9 and Pip](https://www.python.org/).
+First of all we need [Python >=3.10 and Pip](https://www.python.org/).
+Currently we recommend Python 3.11.
 
+Check the installed versions with:
 ```
 python -V
 pip --version
 ```
 
-Note that on all platforms except Windows the Python 3 executables are mostly called `python3` while `pip3`/`pip` don't exist at all. But to be compatible with Windows _(yes, that's the wrong way around - blame MS!)_, we currently need the `python` and `pip` symlinks point to `python3` and `pip3` _(or better `python3 -m pip`)_ respectively.  Everything else may work, but has not been tested.
+Note that on POSIX platforms the Python 3 executable is called `python3`, while under Windows it is called `python`. 
+Additionally, under POSIX, `pip3` is not installed per default, while under Windows it is installed with Python as `pip`. 
+To be compatible with Windows _(yes, that's the wrong way around - blame MS!)_, we currently need the `python` and `pip` symlinks point to `python3` and `pip3` _(or better `python3 -m pip`)_ respectively.  Everything else may work, but has not been tested.
 
 Note also that on current Windows versions [Microsoft hijacks](https://docs.microsoft.com/en-us/windows/python/faqs#why-does-running-pythonexe-open-the-microsoft-store) the `python` and `python3` executables.
 
 
 ### Install Conan
 
 [Conan](https://conan.io) is the package manager used to build our third party libraries.
-Additionally, we are using [Conan Package Tools](https://github.com/conan-io/conan-package-tools) to generate multiple binary packages from a recipe with ease.
-
-Both packages can be installed using pip:
+On Windows, use:
 ```
-python -m pip install -U conan conan-package-tools
+python -m pip install -U conan packaging spdx-license-list tomli
 ```
 
-Now conan should be installed:
+On Linux, use:
 ```
-conan --version
+pip3 install -U conan packaging spdx-license-list tomli pyelftools
 ```
 
-### Install MeVisLab Build Tool
-
-`mbt`, the MeVisLab Build Tool, is a small wrapper for Conan and the Conan Package Tools.
-It mainly ensures that Conan is properly configured and initialized before invoking conan itself.
-
-```
-python -m pip install -U git+http://gitlab.mevis.lokal/mevislab/mbt.git
-```
 
 ## Build a package
 
-### Using mbt, conan-package-tools or conan
-
-All wrappers (`mbt`, `conan-package-tools`) are just convenience.
-They make certain things easier, while making advanced things very difficult.
-That seems to be the nature of wrappers. Therefore it is always possible to
-work without these tools.
-
-So a recipe can be built directly with `mbt`:
-
+To build the debug and release versions of a package:
 ```
 cd recipes/<recipe_name>
-mbt build
-```
-
-_Note_: If you are building under Windows, have several Visual Studio versions installed and want to use _not_ the
-newest one, you have to set an environment variable with the desired version to communicate this to `mbt`:
-```
-SET CONAN_VISUAL_VERSIONS=16
+conan create -s build_type=Debug .
+conan create -s build_type=Release .
 ```
 
-Or using `conan-package-tools`:
+If you have the `conan-config` package installed (MeVisLab internal only, see README.md in the main MeVisLab directory), you can instead use:
 ```
 cd recipes/<recipe_name>
-./build.py
+conan tp:build .
 ```
+to build both the debug and release packages.
+
 
-Or using `conan`:
+To fetch the package sources (includes applying patches):
 ```
 cd recipes/<recipe_name>
-conan create .
+conan source .
 ```
 
+
 ## Jenkins Integration
 
 ### Pipeline Description
-There are mainly two Jenkinsfiles that control the build of all thirdparty library and tools: Jenkinsfile and JenkinsfileLibrary. The first parses the `build_configuration.yml` and triggers the build of one tier after the other, starting with tier0. For further details see the chapter Build Configuration
+There are mainly two Jenkins files that control the build of all thirdparty libraries and tools: `Jenkinsfile` and `JenkinsfileLibrary` (both in the repository root). The first file parses `build_configuration.yml` and triggers the sequential build of all tiers, starting with tier0. For further details see the chapter _Build Configuration_.
 
-The conan package system is written in a way that it checks if the package itself or one of its dependencies has been changed since the last successful build. If nothing has changed then the build and archiving step is been skipped.
-Since even this check takes a certain amount of time, an additional optimization has been implemented. All changed files are collected since the last successful build of the complete thirdparty/branch build. And only those directly affected projects and the tiers below are triggered to be rebuild. This shortens the build time enormously. If one of the files `Jenkinsfile`, `JenkinsfileLibrary`, or `build_configuration.yml` is part of any changeset, then this optimisation is skipped and all tiers with all projects are build.
+The conan package system is written in a way that it checks if the package itself or one of its dependencies has been changed since the last successful build. If nothing has changed, then the build and archiving step is skipped.
+Since even this check takes a certain amount of time, an additional optimization has been implemented. All changed files are collected since the last successful build of the complete thirdparty/branch build. And only those directly affected projects and the tiers below are triggered to be rebuild. This shortens the build time enormously. If one of the files `Jenkinsfile`, `JenkinsfileLibrary`, or `build_configuration.yml` is part of any changeset, then this optimization is skipped and all tiers with all projects are build.
 
 ### Build Configuration
-The build configuration is organised in the `build_configuration.yml` file. All libraries and tools that are needed to build MeVisLab are organised in this file. Since it very tedios and cumpersome to descripe smallest possible dependecy graph, the dependencies are broken down in different tiers. The content of the different tier is organised according to the dependencies of the individual libraries and tools. So if a e.g. a library A depends on an other library B, then B must be referenced in an one of the upper tiers.
+The build configuration is described in the `build_configuration.yml` file, which references all the libraries and tools needed to build MeVisLab.
+Organizing the dependencies can be very tedious and cumbersome, especially when attempting to describe the smallest possible dependency graph.
+To simplify this, dependencies are broken down into different tiers, with the content of each tier organized according to the dependencies of the individual libraries and tools.
+For instance, if library A depends on another library B, then B must be referenced in one of the upper tiers (e.g. a tier with a lower number).
 
-The build of each library and tool for all specified platform and build types must finish in a defined time. There is a default, that is been used for all packages. In case that a certain package needs much more time, e.g. qt5, then there is the possibility to define a timeout exception.
+The build of each library and tool for all specified platforms and build types must finish within a defined time frame. There is a default timeout that is used for all packages.
+However, if a certain package requires significantly more time, there is the possibility to define a timeout exception.
 
 These are the parameters that are defined in the file:
 
 | Parameter | Description |
 | --------- | ------------|
-| timeout_default: | Default time in minutes for all not other specified packages. |
-| timeout_exception: | A map of all packages with their individual timeouts. |
-| tiers: | It must contain an ordered list of all tiers, starting with tier0 |
+| timeout_default: | Default time in minutes for all packages not specified otherwise |
+| timeout_exception: | A map of all packages with their individual timeouts |
+| tiers: | An ordered list of all tiers, starting with tier0 |

recipes/.conanignore

@@ -0,0 +1 @@
+*

recipes/7zip/conanfile.py

@@ -0,0 +1,63 @@
+from conan import ConanFile
+from conan.tools.files import copy, get, replace_in_file
+from conan.tools.layout import basic_layout
+from conan.tools.microsoft import NMakeToolchain
+from conans.errors import ConanInvalidConfiguration
+
+required_conan_version = ">=2.2.2"
+
+
+class ConanRecipe(ConanFile):
+    name = "7zip"
+    version = "23.01"
+    license = ("LGPL-2.1-or-later", "BSD-3-Clause")
+    homepage = "https://www.7-zip.org"
+    description = "7-Zip is a file archiver with a high compression ratio"
+    settings = "os", "arch", "compiler", "build_type"
+    package_type = "application"
+
+    def package_id(self):
+        self.info.settings.rm_safe("build_type")
+        self.info.settings.rm_safe("compiler.runtime_type")
+
+    def configure(self):
+        if self.settings.os != "Windows":
+            raise ConanInvalidConfiguration(f"{self.name} is only supported on Windows")
+
+    def validate(self):
+        if self.settings.os != "Windows":
+            raise ConanInvalidConfiguration(f"{self.name} is only supported on Windows")
+
+    def validate_build(self):
+        if self.settings.build_type != "Release":
+            raise ConanInvalidConfiguration(f"{self.name} is built in release mode only.")
+
+    def layout(self):
+        basic_layout(self, src_folder="src")
+
+    def source(self):
+        version = "".join(self.version.split("."))
+        get(self,
+            url=f"https://sourceforge.net/projects/sevenzip/files/7-Zip/{self.version}/7z{version}-src.tar.xz",
+            sha256="356071007360e5a1824d9904993e8b2480b51b570e8c9faf7c0f58ebe4bf9f74")
+
+    def generate(self):
+        tc = NMakeToolchain(self)
+        tc.generate()
+
+    def build(self):
+        make_file = self.source_path / "CPP" / "Build.mak"
+        make_file.chmod(0o644)
+        replace_in_file(self, make_file, "-MT", f"-{self.settings.compiler.runtime}")
+        replace_in_file(self, make_file, "-MD", f"-{self.settings.compiler.runtime}")
+        self.run(f"nmake /f makefile PLATFORM=x64", cwd=self.source_path / "CPP" / "7zip")
+
+    def package(self):
+        copy(self, "License.txt", dst=self.package_path / "licenses", src=self.source_path / "DOC")
+        copy(self, "unRarLicense.txt", dst=self.package_path / "licenses", src=self.source_path / "DOC")
+        copy(self, "*/7z.exe", dst=self.package_path / "bin", src=self.source_path / "CPP" / "7zip", keep_path=False)
+        copy(self, "*/7z.dll", dst=self.package_path / "bin", src=self.source_path / "CPP" / "7zip", keep_path=False)
+
+    def package_info(self):
+        self.cpp_info.includedirs.clear()
+        self.cpp_info.libdirs.clear()

recipes/7zip/test_package/conanfile.py

@@ -0,0 +1,14 @@
+from conan import ConanFile
+from conan.tools.build import can_run
+
+
+class TestPackageConan(ConanFile):
+    settings = "os", "arch", "compiler", "build_type"
+    test_type = "explicit"
+
+    def build_requirements(self):
+        self.tool_requires(self.tested_reference_str)
+
+    def test(self):
+        if can_run(self):
+            self.run("7z.exe --help")

recipes/abseil/conanfile.py

@@ -0,0 +1,59 @@
+from conan import ConanFile
+from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
+from conan.tools.files import copy, get, rmdir
+import os
+
+required_conan_version = ">=2.2.2"
+
+
+class ConanRecipe(ConanFile):
+    name = "abseil"
+    version = "20240116.1"
+    homepage = "https://abseil.io"
+    description = "Collection of C++ libraries from Google"
+    license = "Apache-2.0"
+    settings = "os", "arch", "compiler", "build_type"
+    exports_sources = "patches/*.patch"
+    package_type = "static-library"
+
+    mlab_hooks = {"cmake_files.exclude": ["lib/cmake/*.cmake"]}
+
+    def layout(self):
+        cmake_layout(self, src_folder="src")
+
+    def source(self):
+        get(
+            self,
+            sha256="3c743204df78366ad2eaf236d6631d83f6bc928d1705dd0000b872e53b73dc6a",
+            url=f"https://github.com/abseil/abseil-cpp/archive/refs/tags/{self.version}.tar.gz",
+            strip_root=True,
+        )
+
+    def generate(self):
+        tc = CMakeToolchain(self)
+        tc.variables["CMAKE_DEBUG_POSTFIX"] = "_d"
+        tc.variables["BUILD_SHARED_LIBS"] = False
+        tc.variables["CMAKE_POSITION_INDEPENDENT_CODE"] = True
+        tc.variables["ABSL_ENABLE_INSTALL"] = True
+        tc.variables["ABSL_PROPAGATE_CXX_STD"] = True
+        tc.variables["BUILD_TESTING"] = False
+        tc.generate()
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
+
+    def package(self):
+        copy(self, pattern="LICENSE", src=self.source_path, dst=self.package_path / "licenses")
+        cmake = CMake(self)
+        cmake.install()
+        rmdir(self, self.package_path / "lib" / "pkgconfig")
+
+    def package_info(self):
+        self.cpp_info.builddirs.append(os.path.join("lib", "cmake"))
+        self.cpp_info.set_property("cmake_find_mode", "none")  # do NOT generate cmake files, they are generated by abseil
+        self.cpp_info.set_property("cmake_file_name", "absl")  # let CMake search for absl, not abseil (the package name)
+        self.cpp_info.set_property(
+            "cmake_target_name", "absl::base"
+        )  # let CMake link to absl::base, not abseil::abseil (derived from the package name)

recipes/abseil/test_package/CMakeLists.txt

@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 3.27)
+project(test_package LANGUAGES CXX)
+
+find_package(absl REQUIRED)
+
+add_executable(test_package test_package.cpp)
+
+target_link_libraries(test_package PRIVATE absl::strings absl::flat_hash_map absl::flat_hash_set absl::int128 absl::time)

recipes/abseil/test_package/conanfile.py

@@ -0,0 +1,25 @@
+from conan import ConanFile
+from conan.tools.build import can_run
+from conan.tools.cmake import CMake, cmake_layout
+import os
+
+
+class TestPackage(ConanFile):
+    settings = "os", "arch", "compiler", "build_type"
+    generators = "CMakeToolchain", "CMakeDeps", "VirtualRunEnv"
+
+    def layout(self):
+        cmake_layout(self)
+
+    def requirements(self):
+        self.requires(self.tested_reference_str)
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
+
+    def test(self):
+        if can_run(self):
+            bin_path = os.path.join(self.cpp.build.bindirs[0], "test_package")
+            self.run(bin_path, env="conanrun")

recipes/abseil/test_package/test_package.cpp

@@ -0,0 +1,25 @@
+#include <string>
+#include <utility>
+#include <iostream>
+#include <vector>
+
+#include <absl/strings/str_cat.h>
+#include <absl/strings/str_split.h>
+#include <absl/container/flat_hash_map.h>
+#include <absl/container/flat_hash_set.h>
+#include <absl/numeric/int128.h>
+#include <absl/time/time.h>
+#include <absl/types/variant.h>
+
+int main()
+{
+    absl::Time t1 = absl::Now();
+    absl::Time t2 = absl::Time();
+    absl::Time t3 = absl::UnixEpoch();
+
+    absl::variant<int> v1 = absl::variant<int>();
+    absl::bad_variant_access e1;
+
+    std::string const year = absl::FormatTime("%Y", absl::Now(), absl::UTCTimeZone());
+    std::cout << "year " << year << std::endl;
+}