[libdb] Conan 2.0 migration

recipes/libdb/all/conandata.yml

@@ -5,10 +5,11 @@ sources:
 patches:
   "5.3.28":
     - patch_file: "patches/0001-rename_atomic_compare_exchange.patch"
-      base_path: "source_subfolder"
+      patch_description: "Rename __atomic_compare_exchange to __atomic_compare_exchange_db"
+      patch_type: "portability"
     - patch_file: "patches/0002-no-conditional-tcl-include.patch"
-      base_path: "source_subfolder"
+      patch_description: "Always include tcl.h. Remove conditions."
+      patch_type: "conan"
     - patch_file: "patches/0003-msvc-db_tcl-add-static-configuration.patch"
-      base_path: "source_subfolder"
-    - patch_file: "patches/0004-msvc-tcl-include-conanbuildinfo-props.patch"
-      base_path: "source_subfolder"
+      patch_description: "Add static configuration"
+      patch_type: "conan"

recipes/libdb/all/conanfile.py

@@ -1,14 +1,15 @@
-from conan import ConanFile
+from conan import ConanFile, conan_version
 from conan.errors import ConanInvalidConfiguration
 from conan.tools.files import apply_conandata_patches, export_conandata_patches, get, copy, replace_in_file, rename, rm, rmdir
-from conan.tools.microsoft import is_msvc, check_min_vs, unix_path
+from conan.tools.microsoft import MSBuild, MSBuildDeps, MSBuildToolchain, is_msvc, check_min_vs, vs_layout
+from conan.tools.gnu import Autotools, AutotoolsDeps, AutotoolsToolchain
+from conan.tools.layout import basic_layout
 from conan.tools.scm import Version
-# FIXME: Needs to be migrted to Conan v2
-from conans import AutoToolsBuildEnvironment, MSBuild
-from conans import tools as legacy_tools
+from conan.tools.apple import fix_apple_shared_install_name
 
 import glob
 import os
+import shutil
 
 required_conan_version = ">=1.55.0"
 
@@ -35,13 +36,6 @@ class LibdbConan(ConanFile):
         "with_cxx": False,
     }
 
-    generators = "visual_studio"
-
-    _autotools = None
-
-    @property
-    def _source_subfolder(self):
-        return "source_subfolder"
 
     @property
     def _mingw_build(self):
@@ -51,18 +45,14 @@ def _mingw_build(self):
     def _settings_build(self):
         return getattr(self, "settings_build", self.settings)
 
-    @property
-    def _user_info_build(self):
-        return getattr(self, "user_info_build", self.deps_user_info)
-
     def export_sources(self):
         export_conandata_patches(self)
 
     def config_options(self):
         if self.settings.os == "Windows":
-            del self.options.fPIC
-        if self.settings.compiler == "Visual Studio":
-            del self.options.with_cxx
+            self.options.rm_safe("fPIC")
+        if is_msvc(self):
+            self.options.rm_safe("with_cxx")
 
     def configure(self):
         if self.options.shared:
@@ -76,90 +66,99 @@ def requirements(self):
             self.requires("tcl/8.6.10")
 
     def validate(self):
-        if is_msvc(self) and check_min_vs(self, "191", raise_invalid=False):
+        if is_msvc(self) and check_min_vs(self, "192", raise_invalid=False):
             # FIXME: it used to work with previous versions of Visual Studio 2019 in CI of CCI.
+            # Currently won't work with Visual Studio 2019 or newer
             raise ConanInvalidConfiguration(f"{self.ref} Visual Studio 2019 is currently not supported. Contributions are welcomed!")
 
         if self.settings.os == "Macos" and self.settings.arch == "armv8":
             raise ConanInvalidConfiguration(f"{self.ref} Macos Apple Sillicon is currently not supported. Contributions are welcomed!")
 
         if self.options.get_safe("with_cxx"):
             if self.settings.compiler == "clang" and Version(self.settings.compiler.version) < "6":
-                raise ConanInvalidConfiguration(f"{self.ref} does no support clang<6 with_cxx=True")
+                raise ConanInvalidConfiguration(f"{self.ref} does not support clang<6 with_cxx=True")
             if self.settings.compiler == "apple-clang" and Version(self.settings.compiler.version) < "10":
-                raise ConanInvalidConfiguration(f"{self.ref} does no support apple-clang<10 with_cxx=True")
+                raise ConanInvalidConfiguration(f"{self.ref} does not support apple-clang<10 with_cxx=True")
 
     def build_requirements(self):
-        if self._settings_build.os == "Windows":
-            self.win_bash = True
-            if not self.conf.get("tools.microsoft.bash:path", check_type=str):
-                self.tool_requires("msys2/cci.latest")
+        if not self._settings_build.os == "Windows":
+            self.tool_requires("gnu-config/cci.20201022")
+
+    def layout(self):
+        if is_msvc(self):
+            vs_layout(self)
+        else:
+            basic_layout(self, src_folder="src")
 
     def source(self):
-        get(self, **self.conan_data["sources"][self.version], destination=self._source_subfolder, strip_root=True)
+        get(self, **self.conan_data["sources"][self.version], destination=self.source_folder, strip_root=True)
 
     def _patch_sources(self):
         apply_conandata_patches(self)
 
-        if is_msvc(self):
+        if not is_msvc(self):
             for subdir in [
                 "dist",
                 os.path.join("lang", "sql", "jdbc"),
                 os.path.join("lang", "sql", "odbc"),
                 os.path.join("lang", "sql", "sqlite"),
             ]:
-                for gnu_config in [
-                    self.conf.get("user.gnu-config:config_guess", check_type=str),
-                    self.conf.get("user.gnu-config:config_sub", check_type=str),
-                ]:
-                    if gnu_config:
-                        copy(self, os.path.basename(gnu_config), src=os.path.dirname(gnu_config), dst=os.path.join(self._source_subfolder, subdir))
-
-        for file in glob.glob(os.path.join(self._source_subfolder, "build_windows", "VS10", "*.vcxproj")):
+                shutil.copy(self.dependencies.build["gnu-config"].conf_info.get("user.gnu-config:config_sub"),
+                            os.path.join(self.source_folder, subdir, "config.sub"))
+                shutil.copy(self.dependencies.build["gnu-config"].conf_info.get("user.gnu-config:config_guess"),
+                            os.path.join(self.source_folder, subdir, "config.guess"))
+
+        for file in glob.glob(os.path.join(self.source_folder, "build_windows", "VS10", "*.vcxproj")):
+            # The WindowsTargetPlatformVersion selected below will depend on what Windows SDK is installed.
             replace_in_file(self, file,
                                   "<PropertyGroup Label=\"Globals\">",
-                                  "<PropertyGroup Label=\"Globals\"><WindowsTargetPlatformVersion>10.0.17763.0</WindowsTargetPlatformVersion>")
+                                  # 10.0 should select the "latest" SDK available, but doesn't always work. It may be necessary to specify a specific version
+                                  "<PropertyGroup Label=\"Globals\"><WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>")
+                                  #"<PropertyGroup Label=\"Globals\"><WindowsTargetPlatformVersion>10.0.20348.0</WindowsTargetPlatformVersion>")
+                                  #"<PropertyGroup Label=\"Globals\"><WindowsTargetPlatformVersion>10.0.19041.0</WindowsTargetPlatformVersion>")
 
-        dist_configure = os.path.join(self._source_subfolder, "dist", "configure")
+        dist_configure = os.path.join(self.source_folder, "dist", "configure")
         replace_in_file(self, dist_configure, "../$sqlite_dir", "$sqlite_dir")
         replace_in_file(self, dist_configure,
                               "\n    --disable-option-checking)",
                               "\n    --datarootdir=*)"
                               "\n      ;;"
                               "\n    --disable-option-checking)")
 
-    def _configure_autotools(self):
-        if self._autotools:
-            return self._autotools
-        self._autotools = AutoToolsBuildEnvironment(self, win_bash=legacy_tools.os_info.is_windows)
-        if self.settings.compiler in ["apple-clang", "clang"] and Version(self.settings.compiler.version) >= "12":
-            self._autotools.flags.append("-Wno-error=implicit-function-declaration")
-        conf_args = [
-            "--enable-debug" if self.settings.build_type == "Debug" else "--disable-debug",
-            "--enable-mingw" if self._mingw_build else "--disable-mingw",
-            "--enable-compat185",
-            "--enable-sql",
-        ]
-        if self.options.with_cxx:
-            conf_args.extend(["--enable-cxx", "--enable-stl"])
-        else:
-            conf_args.extend(["--disable-cxx", "--disable-stl"])
+    def generate(self):
+        if is_msvc(self):
+            tc = MSBuildToolchain(self)
+            tc.generate()
 
-        if self.options.shared:
-            conf_args.extend(["--enable-shared", "--disable-static"])
+            deps = MSBuildDeps(self)
+
+            deps.generate()
         else:
-            conf_args.extend(["--disable-shared", "--enable-static"])
-        if self.options.with_tcl:
-            conf_args.append("--with-tcl={}".format(unix_path(self, os.path.join(self.deps_cpp_info["tcl"].rootpath, "lib"))))
-        self._autotools.configure(configure_dir=os.path.join(self.source_folder, self._source_subfolder, "dist"), args=conf_args)
-        if self.settings.os == "Windows" and self.options.shared:
-            replace_in_file(self, os.path.join(self.build_folder, "libtool"),
-                                  "\ndeplibs_check_method=",
-                                  "\ndeplibs_check_method=pass_all\n#deplibs_check_method=")
-            replace_in_file(self, os.path.join(self.build_folder, "Makefile"),
-                                  ".a",
-                                  ".dll.a")
-        return self._autotools
+            tc = AutotoolsToolchain(self)
+            tc.configure_args.append("--enable-debug" if self.settings.build_type == "Debug" else "--disable-debug")
+            tc.configure_args.append("--enable-mingw" if self._mingw_build else "--disable-mingw")
+            tc.configure_args.append("--enable-compat185")
+            tc.configure_args.append("--enable-sql")
+            if self.options.with_cxx:
+                tc.configure_args.extend(["--enable-cxx", "--enable-stl"])
+            else:
+                tc.configure_args.extend(["--disable-cxx", "--disable-stl"])
+
+            if self.options.shared:
+                tc.configure_args.extend(["--enable-shared", "--disable-static"])
+            else:
+                tc.configure_args.extend(["--disable-shared", "--enable-static"])
+
+            if self.options.with_tcl:
+                tc.configure_args.append(f"--with-tcl={os.path.join(self.dependencies['tcl'].package_folder, 'lib')}")
+
+            if self.settings.compiler == "apple-clang" and Version(self.settings.compiler.version) >= "12":
+                tc.extra_cflags.append("-Wno-error=implicit-function-declaration")
+
+            tc.generate()
+
+            deps = AutotoolsDeps(self)
+            deps.generate()
 
     @property
     def _msvc_build_type(self):
@@ -174,33 +173,56 @@ def _msvc_build_type(self):
     def _msvc_arch(self):
         return self._msvc_platforms[str(self.settings.arch)]
 
-    def _build_msvc(self):
-        projects = ["db", "db_sql", "db_stl"]
-        if self.options.with_tcl:
-            projects.append("db_tcl")
-        msbuild = MSBuild(self)
-        upgraded = False
-        for project in projects:
-            msbuild.build(os.path.join(self._source_subfolder, "build_windows", "VS10", "{}.vcxproj".format(project)),
-                          build_type=self._msvc_build_type, platforms=self._msvc_platforms,
-                          upgrade_project=not upgraded)
-            upgraded = True
-
     def build(self):
         self._patch_sources()
         if is_msvc(self):
-            self._build_msvc()
+            #self._build_msvc()
+            projects = ["db", "db_sql", "db_stl"]
+            if self.options.with_tcl:
+                projects.append("db_tcl")
+            msbuild = MSBuild(self)
+            for project in projects:
+                # =================================
+                # TODO: To remove once https://github.com/conan-io/conan/pull/12817 is available in conan client
+                project_file = os.path.join(self.source_folder, "build_windows", "VS10", f"{project}.vcxproj")
+                conantoolchain_props = os.path.join(self.generators_folder, "conantoolchain.props")
+                toolset = MSBuildToolchain(self).toolset
+                replace_in_file(
+                    self, project_file,
+                    "</ProjectConfiguration>",
+                    f"  <PlatformToolset>{toolset}</PlatformToolset>\n    </ProjectConfiguration>",
+                )
+                replace_in_file(
+                    self, project_file,
+                    "</CharacterSet>",
+                    f"</CharacterSet>\n    <PlatformToolset>{toolset}</PlatformToolset>",
+                )
+                replace_in_file(
+                    self, project_file,
+                    "<Import Project=\"$(VCTargetsPath)\\Microsoft.Cpp.targets\"/>",
+                    f"<Import Project=\"{conantoolchain_props}\"/>\n  <Import Project=\"$(VCTargetsPath)\\Microsoft.Cpp.targets\"/>",
+                )
+                # =================================
+
+                build_type = "{}{}".format(
+                    "" if self.options.shared else "Static ",
+                    "Debug" if self.settings.build_type == "Debug" else "Release",
+                )
+                msbuild.build_type = build_type if Version(conan_version).major >= 2 else f"\"{build_type}\""
+                msbuild.platform = "Win32" if self.settings.arch == "x86" else msbuild.platform
+                msbuild.build(sln=project_file)
         else:
-            autotools = self._configure_autotools()
+            autotools = Autotools(self)
+            autotools.configure(build_script_folder=os.path.join(self.source_folder, "dist"))
             autotools.make()
 
     def package(self):
-        copy(self, "LICENSE", src=self._source_subfolder, dst=os.path.join(self.package_folder, "licenses"))
+        copy(self, "LICENSE", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"))
         bindir = os.path.join(self.package_folder, "bin")
         libdir = os.path.join(self.package_folder, "lib")
         if is_msvc(self):
-            build_windows = os.path.join(self._source_subfolder, "build_windows")
-            build_dir = os.path.join(self._source_subfolder, "build_windows", self._msvc_arch, self._msvc_build_type)
+            build_windows = os.path.join(self.source_folder, "build_windows")
+            build_dir = os.path.join(self.source_folder, "build_windows", self._msvc_arch, self._msvc_build_type)
             copy(self, "*.lib", src=build_dir, dst=libdir)
             copy(self, "*.dll", src=build_dir, dst=bindir)
             for fn in ("db.h", "db.cxx", "db_int.h", "dbstl_common.h"):
@@ -217,7 +239,7 @@ def _lib_to_msvc_lib(lib):
                 rename(self, os.path.join(libdir, "{}.lib".format(msvc_lib)),
                              os.path.join(libdir, "{}.lib".format(lib)))
         else:
-            autotools = self._configure_autotools()
+            autotools = Autotools(self)
             autotools.install()
 
             if self.settings.os == "Windows":
@@ -244,6 +266,7 @@ def _lib_to_msvc_lib(lib):
             if not self.options.shared:
                 # autotools installs the static libraries twice as libXXX.a and libXXX-5.3.a ==> remove libXXX-5.3.a
                 rm(self, "*-{}.a".format(".".join(self._major_minor_version)), libdir)
+            fix_apple_shared_install_name(self)
 
     @property
     def _major_minor_version(self):
@@ -258,8 +281,8 @@ def _libs(self):
         if self.options.get_safe("with_cxx"):
             libs.extend(["db_cxx", "db_stl"])
         libs.extend(["db_sql", "db"])
-        if self.settings.compiler == "Visual Studio":
-            libs = ["lib{}".format(lib) for lib in libs]
+        if is_msvc(self):
+            libs = [f"lib{libname}" for libname in libs]
         return libs
 
     def package_info(self):
@@ -268,5 +291,5 @@ def package_info(self):
             self.cpp_info.defines = ["DB_USE_DLL"]
         if self.settings.os in ["Linux", "FreeBSD"]:
             self.cpp_info.system_libs.extend(["dl", "pthread"])
-        elif self.settings.os == "Windows" :
+        elif self.settings.os == "Windows":
             self.cpp_info.system_libs.append("ws2_32")

recipes/libdb/all/test_package/CMakeLists.txt

@@ -1,8 +1,7 @@
-cmake_minimum_required(VERSION 3.1)
-project(test_package C)
+cmake_minimum_required(VERSION 3.15)
+project(PackageTest C)
 
-include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
-conan_basic_setup()
+find_package(libdb CONFIG REQUIRED)
 
-add_executable(${PROJECT_NAME} test_package.c)
-target_link_libraries(${PROJECT_NAME} ${CONAN_LIBS})
+add_executable(example src/test_package.c)
+target_link_libraries(example libdb::libdb)

recipes/libdb/all/test_package/conanfile.py

@@ -1,16 +1,26 @@
-from conans import ConanFile, CMake, tools
 import os
 
+from conan import ConanFile
+from conan.tools.cmake import CMake, cmake_layout
+from conan.tools.build import can_run
 
-class TestPackageConan(ConanFile):
-    settings = "os", "arch", "compiler", "build_type"
-    generators = "cmake"
+
+class fooTestConan(ConanFile):
+    settings = "os", "compiler", "build_type", "arch"
+    generators = "CMakeDeps", "CMakeToolchain"
+
+    def requirements(self):
+        self.requires(self.tested_reference_str)
 
     def build(self):
         cmake = CMake(self)
         cmake.configure()
         cmake.build()
 
+    def layout(self):
+        cmake_layout(self)
+
     def test(self):
-        if not tools.cross_building(self):
-            self.run(os.path.join("bin", "test_package"), run_environment=True)
+        if can_run(self):
+            cmd = os.path.join(self.cpp.build.bindir, "example")
+            self.run(cmd, env="conanrun")

recipes/libdb/all/test_package/test_package.c → recipes/libdb/all/test_package/src/test_package.c

@@ -17,5 +17,6 @@ int main(int argc, char *argv[]) {
         puts("DP->close failed\n");
         return EXIT_FAILURE;
     }
+    puts("libdb test_package success!\n");
     return EXIT_SUCCESS;
 }