conanfile.py

from conan import ConanFile
from conan.errors import ConanInvalidConfiguration
from conan.tools.build import check_min_cppstd
from conan.tools.cmake import CMakeToolchain, CMakeDeps, CMake
from conan.tools.files import copy
from conan.tools.scm import Version
from os.path import join

required_conan_version = ">=2.0"

class SISLConan(ConanFile):
    name = "sisl"
    version = "14.9.0"

    homepage = "https://github.com/eBay/sisl"
    description = "Library for fast data structures, utilities"
    topics = ("ebay", "components", "core", "efficiency")
    url = "https://github.com/eBay/sisl"
    license = "Apache-2.0"

    settings = "arch", "os", "compiler", "build_type"

    options = {
                "shared": ['True', 'False'],
                "fPIC": ['True', 'False'],
                "coverage": ['True', 'False'],
                "sanitize": ['address', 'thread', 'False'],
                'metrics': ['False', 'True'],
                'grpc': ['False', 'True'],
                'http': ['False', 'True'],
                'malloc_impl' : ['libc', 'tcmalloc', 'jemalloc'],
              }
    default_options = {
                'shared': False,
                'fPIC': True,
                'coverage': False,
                'sanitize': False,
                'metrics': True,
                'grpc': True,
                'http': True,
                'malloc_impl': 'libc',
            }

    exports_sources = (
                "LICENSE",
                "CMakeLists.txt",
                "cmake/*",
                "include/*",
                "src/*",
                "tsan.supp",
            )

    def _min_cppstd(self):
        return 23

    def _use_breakpad(self):
        # breakpad/cci.20210521 is frozen (2021) and fails to build with gcc >= 16; keep it for the
        # other Linux/libstdc++ toolchains it does support.
        if self.settings.os not in ["Linux"] or self.settings.compiler.get_safe("libcxx") == "libc++":
            return False
        if self.settings.compiler == "gcc" and Version(self.settings.compiler.version) >= "16":
            return False
        return True

    def validate(self):
        if self.settings.compiler.get_safe("cppstd"):
            check_min_cppstd(self, self._min_cppstd())

    def configure(self):
        if self.options.http:
            self.options["cpp-httplib"].with_openssl = True
        if not self.options.metrics and self.options.grpc:
            raise ConanInvalidConfiguration("gRPC support requires metrics option!")

        if self.options.shared:
            self.options.rm_safe("fPIC")
        if self.settings.build_type == "Debug":
            if self.options.coverage and self.options.sanitize != "False":
                raise ConanInvalidConfiguration("Sanitizer does not work with Code Coverage!")
            if self.conf.get("tools.build:skip_test", default=False):
                if self.options.coverage or self.options.sanitize != "False":
                    raise ConanInvalidConfiguration("Coverage/Sanitizer requires Testing!")

    def build_requirements(self):
        if not self.conf.get("tools.build:skip_test", default=False):
            self.test_requires("gtest/1.17.0")
            if self.options.metrics:
                self.test_requires("benchmark/1.9.5")

    def requirements(self):
        # Required
        self.requires("boost/1.85.0", transitive_headers=True)
        self.requires("cxxopts/3.3.1", transitive_headers=True)
        self.requires("nlohmann_json/3.12.0", transitive_headers=True)
        self.requires("spdlog/1.17.0", transitive_headers=True)
        self.requires("zmarok-semver/1.1.0", transitive_headers=True)
        # Public sisl/async coroutine headers (task.hpp/when_all.hpp) include <exec/...>; ship stdexec
        # transitively so package consumers resolve it without their own FetchContent.
        self.requires("stdexec/25.09", transitive_headers=True)
        self.requires("lz4/1.10.0", override=True)
        if self._use_breakpad():
            self.requires("breakpad/cci.20210521")

        # ARM needs unreleased versionof libunwind
        if not self.settings.arch in ['x86', 'x86_64']:
            self.requires("libunwind/1.8.2@baydb/develop", override=True)

        if self.options.metrics:
            self.requires("flatbuffers/24.12.23", transitive_headers=True)
            self.requires("prometheus-cpp/1.3.0", transitive_headers=True)
            self.requires("snappy/[^1.2]", transitive_headers=True)
            self.requires("userspace-rcu/nu2.0.14.0", transitive_headers=True)

        if self.options.grpc:
            self.requires("grpc/1.69.0", transitive_headers=True)

        if self.options.http:
            self.requires("cpp-httplib/0.39.0", transitive_headers=True)

        # Memory allocation
        if self.options.malloc_impl == "tcmalloc":
            self.requires("gperftools/2.17.2", transitive_headers=True)
        elif self.options.malloc_impl == "jemalloc":
            self.requires("jemalloc/5.3.0", transitive_headers=True)

    def layout(self):
        self.folders.source = "."
        if self.options.get_safe("sanitize") and self.options.sanitize != "False":
            self.folders.build = join("build", f"Sanitized-{self.options.sanitize}")
        elif self.options.get_safe("coverage"):
            self.folders.build = join("build", "Coverage")
        else:
            self.folders.build = join("build", str(self.settings.build_type))
        self.folders.generators = join(self.folders.build, "generators")

        self.cpp.build.components["options"].libdirs = ["src/options"]
        self.cpp.package.components["options"].libs = ["sisl_options"]
        self.cpp.build.components["logging"].libdirs = ["src/logging"]
        self.cpp.package.components["logging"].libs = ["sisl_logging"]

        self.cpp.build.components["sobject"].libdirs = ["src/sobject"]
        self.cpp.package.components["sobject"].libs = ["sisl_sobject"]
        if self.settings.os in ["Linux"]:
            self.cpp.build.components["file_watcher"].libdirs = ["src/file_watcher"]
            self.cpp.package.components["file_watcher"].libs = ["sisl_file_watcher"]
        self.cpp.build.components["version"].libdirs = ["src/version"]
        self.cpp.package.components["version"].libs = ["sisl_version"]
        self.cpp.package.components["sisl"].libs = [""]

        if self.options.metrics:
            self.cpp.build.components["settings"].libdirs = ["src/settings"]
            self.cpp.package.components["settings"].libs = ["sisl_settings"]
            self.cpp.build.components["metrics"].libdirs = ["src/metrics"]
            self.cpp.package.components["metrics"].libs = ["sisl_metrics"]
            self.cpp.build.components["buffer"].libdirs = ["src/fds"]
            self.cpp.package.components["buffer"].libs = ["sisl_buffer"]
            self.cpp.build.components["cache"].libdirs = ["src/cache"]
            self.cpp.package.components["cache"].libs = ["sisl_cache"]

        if self.options.grpc:
            self.cpp.build.components["grpc"].libdirs = ["src/grpc"]
            self.cpp.package.components["grpc"].libs = ["sisl_grpc"]
            self.cpp.build.components["flip"].includedirs = ["src/flip"]
            self.cpp.build.components["flip"].libdirs = ["src/flip"]
            self.cpp.package.components["flip"].libs = ["flip"]

        if self.options.http:
            self.cpp.build.components["http"].libdirs = ["src/http"]
            self.cpp.package.components["http"].libs = ["sisl_http"]

        self.cpp.package.includedirs = ["include"] # includedirs is already set to 'include' by
        self.cpp.package.libdirs = ["lib"]

    def generate(self):
        # This generates "conan_toolchain.cmake" in self.generators_folder
        tc = CMakeToolchain(self)
        tc.variables["CONAN_CMAKE_SILENT_OUTPUT"] = "ON"
        tc.variables["ADDRESS_SANITIZER_ON"] = "OFF"
        tc.variables["THREAD_SANITIZER_ON"] = "OFF"
        tc.variables["BUILD_COVERAGE"] = "OFF"
        tc.variables['MALLOC_IMPL'] = self.options.malloc_impl
        tc.preprocessor_definitions["PACKAGE_VERSION"] = self.version
        tc.preprocessor_definitions["PACKAGE_NAME"] = self.name
        if self.settings.build_type == "Debug":
            if self.options.get_safe("coverage"):
                tc.variables['BUILD_COVERAGE'] = 'ON'
            elif self.options.get_safe("sanitize") and self.options.sanitize != "False":
                if self.options.sanitize == "thread":
                    tc.variables['THREAD_SANITIZER_ON'] = 'ON'
                else:
                    tc.variables['ADDRESS_SANITIZER_ON'] = 'ON'

        # Pin generator tool paths to conan-managed binaries.
        # cmake's find_program will otherwise pick up incompatible system tools
        # (e.g. Arch Linux ships protoc 34.x while grpc 1.69.0 pulls protobuf 4.x via conan).
        if self.options.metrics:
            tc.cache_variables["FLATBUFFERS_FLATC_EXECUTABLE"] = join(
                self.dependencies["flatbuffers"].package_folder, "bin", "flatc")
        if self.options.grpc:
            protoc_path = join(self.dependencies["protobuf"].package_folder, "bin", "protoc")
            tc.cache_variables["PROTOC_PROGRAM"] = protoc_path
            tc.cache_variables["Protobuf_PROTOC_EXECUTABLE"] = protoc_path
            tc.cache_variables["GRPC_CPP_PLUGIN_PROGRAM"] = join(
                self.dependencies["grpc"].package_folder, "bin", "grpc_cpp_plugin")

        tc.generate()

        # This generates "boost-config.cmake" and "grpc-config.cmake" etc in self.generators_folder
        deps = CMakeDeps(self)
        deps.generate()

    def build(self):
        cmake = CMake(self)
        cmake.configure()
        cmake.build()
        if not self.conf.get("tools.build:skip_test", default=False):
            self.run(f"ctest --test-dir '{self.build_folder}' --output-on-failure")

    def package(self):
        lib_dir = join(self.package_folder, "lib")
        copy(self, "LICENSE", self.source_folder, join(self.package_folder, "licenses"), keep_path=False)
        copy(self, "*.lib", self.build_folder, lib_dir, keep_path=False)
        copy(self, "*.a", self.build_folder, lib_dir, keep_path=False)
        copy(self, "*.so*", self.build_folder, lib_dir, keep_path=False)
        copy(self, "*.dylib*", self.build_folder, lib_dir, keep_path=False)
        copy(self, "*.dll*", self.build_folder, join(self.package_folder, "bin"), keep_path=False)
        copy(self, "*.so*", self.build_folder, lib_dir, keep_path=False)
        copy(self, "*.proto", join(self.source_folder, "src", "flip", "proto"), join(self.package_folder, "proto", "flip"), keep_path=False)
        copy(self, "*", join(self.source_folder, "src", "flip", "client", "python"), join(self.package_folder, "bindings", "flip", "python"), keep_path=False)
        copy(self, "*.py", join(self.build_folder, "src", "flip", "proto"), join(self.package_folder, "bindings", "flip", "python"), keep_path=False)

        copy(self, "*.h*", join(self.source_folder, "include"), join(self.package_folder, "include"), keep_path=True)

        gen_dir = join(self.package_folder, "include", "sisl")
        copy(self, "*.pb.h", join(self.build_folder, "src"), gen_dir, keep_path=True)
        copy(self, "*security_config_generated.h", join(self.build_folder, "src"), gen_dir, keep_path=True)
        copy(self, "settings_gen.cmake", join(self.source_folder, "cmake"), join(self.package_folder, "cmake"), keep_path=False)

    def package_info(self):
        self.cpp_info.components["logging"].sharedlinkflags.append("-rdynamic")
        self.cpp_info.components["logging"].exelinkflags.append("-rdynamic")

        self.cpp_info.components["options"].requires.extend([
                "boost::boost",
                "cxxopts::cxxopts",
                ])

        self.cpp_info.components["logging"].requires.extend([
                "options",
                "boost::boost",
                "nlohmann_json::nlohmann_json",
                "spdlog::spdlog",
                ])
        if self._use_breakpad():
            self.cpp_info.components["logging"].requires.append("breakpad::breakpad")
        self.cpp_info.components["sobject"].requires.extend([
                "logging",
                "nlohmann_json::nlohmann_json",
                ])
        if self.settings.os in ["Linux"]:
            self.cpp_info.components["file_watcher"].requires.extend([
                    "logging",
                    ])
        self.cpp_info.components["version"].requires.extend([
                "logging",
                "zmarok-semver::zmarok-semver",
                ])
        # sisl/async coroutine headers (task.hpp/when_all.hpp) include <exec/...>; the umbrella component
        # carries the dependency so consumers of sisl::sisl resolve stdexec.
        sisl_requires = ["sobject", "version", "stdexec::stdexec"]
        if self.settings.os in ["Linux"]:
            sisl_requires.append("file_watcher")
        self.cpp_info.components["sisl"].requires.extend(sisl_requires)

        if self.options.metrics:
            self.cpp_info.components["settings"].requires.extend([
                    "logging",
                    "flatbuffers::flatbuffers",
                    "userspace-rcu::userspace-rcu",
                    ])
            self.cpp_info.components["metrics"].requires.extend([
                    "logging",
                    "prometheus-cpp::prometheus-cpp",
                    "userspace-rcu::userspace-rcu",
                    ])
            self.cpp_info.components["buffer"].requires.extend([
                    "metrics",
                    "snappy::snappy",
                    "userspace-rcu::userspace-rcu",
                    ])
            self.cpp_info.components["cache"].requires.extend([
                    "buffer",
                    ])
            self.cpp_info.components["sisl"].requires.extend([
                    "cache",
                    "settings",
                    ])
        if self.options.grpc:
            self.cpp_info.components["grpc"].requires.extend([
                    "buffer",
                    "grpc::grpc++",
                    ])
            self.cpp_info.components["flip"].requires.extend([
                    "logging",
                    "grpc::grpc++",
                    ])
            self.cpp_info.components["sisl"].requires.extend([
                    "grpc",
                    ])

        if self.options.http:
            self.cpp_info.components["http"].requires.extend([
                    "logging",
                    "cpp-httplib::cpp-httplib",
                    ])
            self.cpp_info.components["http"].defines.append("CPPHTTPLIB_OPENSSL_SUPPORT")
            if self.options.metrics:
                self.cpp_info.components["http"].requires.append("metrics")
                self.cpp_info.components["http"].defines.append("PROMETHEUS_METRICS_REPORTER")

        for component in self.cpp_info.components.values():
            if self.settings.os in ["Linux", "FreeBSD"]:
                component.defines.append("_POSIX_C_SOURCE=200809L")
                component.defines.append("_FILE_OFFSET_BITS=64")
                component.defines.append("_LARGEFILE64")
                component.system_libs.extend(["dl", "pthread"])
                component.exelinkflags.extend(["-Wl,-export-dynamic"])
            if self.options.get_safe("sanitize") and self.options.sanitize != "False":
                if self.options.sanitize == "thread":
                    component.sharedlinkflags.append("-fsanitize=thread")
                    component.exelinkflags.append("-fsanitize=thread")
                else:
                    component.sharedlinkflags.append("-fsanitize=address")
                    component.exelinkflags.append("-fsanitize=address")
                    component.sharedlinkflags.append("-fsanitize=undefined")
                    component.exelinkflags.append("-fsanitize=undefined")
            if self.options.malloc_impl == 'jemalloc':
                component.defines.append("USE_JEMALLOC=1")
                component.requires.extend(["jemalloc::jemalloc"])
            elif self.options.malloc_impl == 'tcmalloc':
                component.defines.append("USING_TCMALLOC=1")
                component.requires.extend(["gperftools::gperftools"])