folkslinux
/
mamba
mirror of https://github.com/mamba-org/mamba.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

improve cmake build options 

create a libmamba-full-static target to expose static deps
remove automagic activation of libmamba build options to fix packaging
add find_package libmamba in micromamba and libmambapy
add umamba MICROMAMBA_LINKAGE option to select libmamba target
update documentation
This commit is contained in:
Adrien DELSALLE 2021-10-28 16:36:22 +02:00
parent b91c830223
commit 73b1760e5e
No known key found for this signature in database
GPG Key ID: 639D9226C33B92BB
9 changed files with 400 additions and 210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
CMakeLists.txt
View File

@ -18,14 +18,10 @@ project(mamba)
# Build options
# =============
option(BUILD_MICROMAMBA "Build micromamba" OFF)
option(BUILD_LIBMAMBA "Build libmamba library" OFF)
option(BUILD_LIBMAMBAPY "Build libmamba Python bindings" OFF)
option(BUILD_LIBMAMBA_TESTS "Build libmamba C++ tests" OFF)
option(MICROMAMBA_STATIC_LINK "" OFF)
option(BUILD_SHARED "" OFF)
option(BUILD_STATIC "" OFF)
option(BUILD_MICROMAMBA "Build micromamba" OFF)
if (MSVC)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /DNOMINMAX")
@ -38,11 +34,6 @@ endif()
# Variants
# ========
if (BUILD_MICROMAMBA OR BUILD_LIBMAMBA_TESTS OR BUILD_LIBMAMBAPY)
set(BUILD_LIBMAMBA ON)
set(BUILD_STATIC ON)
endif()
# libmamba library and tests
if (BUILD_LIBMAMBA)
if (BUILD_LIBMAMBA_TESTS)

204
docs/source/developer_zone/build_locally.rst
View File

@ -56,7 +56,7 @@ Build ``libmamba``
Shared library
**************
Also needs ``BUILD_SHARED`` to be activated:
``BUILD_SHARED`` option needs to be activated:
.. code:: bash
@ -67,10 +67,13 @@ Also needs ``BUILD_SHARED`` to be activated:
-DBUILD_SHARED=ON
make
.. note::
``libmamba`` ``cmake`` target represents the shared library
Static library
**************
Also needs ``BUILD_STATIC`` to be activated:
``BUILD_STATIC`` option needs to be activated:
.. code:: bash
@ -81,16 +84,50 @@ Also needs ``BUILD_STATIC`` to be activated:
-DBUILD_STATIC=ON
make
.. note::
``libmamba-static`` ``cmake`` target represents the static library without any dependency linkage
Fully static library
********************
``BUILD_STATIC_DEPS`` option needs to be activated:
.. code:: bash
mkdir -p build
cd build
cmake .. \
-DBUILD_LIBMAMBA=ON \
-DBUILD_STATIC_DEPS=ON
make
.. note::
``libmamba-full-static`` ``cmake`` target represents the static library with static dependencies linkage
.. note::
The ``libmamba`` static library does not embed the dependencies but the ``cmake`` target will expose those dependencies to any executable linking on it
.. note::
The fully statically lib still has few symbols required from system shared libraries (``glibc`` for instance)
.. warning::
This version of the library has a small difference versus the static and shared ones, on the way the SSL backend of cURL is set
See `libmamba/src/core/fetch.cpp` for more information
Tests
*****
First, compile the ``gtest``-based C++ test suite:
| C++ tests require ``libmamba`` to be built.
| To compile the ``gtest``-based C++ test suite, run:
.. code::
mkdir -p build
cd build
cmake .. \
-DBUILD_LIBMAMBA=ON \
-DBUILD_SHARED=ON \
-DBUILD_LIBMAMBA_TESTS=ON
make
@ -106,15 +143,12 @@ Alternatively you can use:
make test
.. note::
The static version of ``libmamba`` is necessary to build the C++ tests, it will be automatically turned-on
Build ``libmambapy``
====================
The Python bindings of ``libmamba``, ``libmambapy`` can be built by using the ``BUILD_LIBMAMBAPY`` ``cmake`` option.
You can either rely on ``libmamba`` package already installed in your environment and run:
.. code:: bash
mkdir -p build
@ -123,6 +157,26 @@ The Python bindings of ``libmamba``, ``libmambapy`` can be built by using the ``
-DBUILD_LIBMAMBAPY=ON
make
or rebuild ``libmamba`` in the same time:
.. code:: bash
mkdir -p build
cd build
cmake .. \
-DBUILD_LIBMAMBA=ON \
-DBUILD_SHARED=ON \
-DCMAKE_INSTALL_PREFIX=$CONDA_PREFIX \
-DBUILD_LIBMAMBAPY=ON
make
.. note::
When rebuilding ``libmamba``, you also need to install the library in a path it will be found.
Use for that the ``CMAKE_INSTALL_PREFIX`` ``cmake`` option to point your current development environment:
- ``-DCMAKE_INSTALL_PREFIX=$CONDA_PREFIX`` [unix]
- ``-DCMAKE_INSTALL_PREFIX=$CONDA_PREFIX\\Library`` [win]
You'll need to install the target to have the bindings Python sub-module correctly located, then you can use ``pip`` to install that Python package:
.. code:: bash
@ -137,6 +191,9 @@ You'll need to install the target to have the bindings Python sub-module correct
.. note::
The ``--no-deps`` tells ``pip`` to skip the dependencies installation, since they are already installed (``libmamba`` installed using ``cmake``)
.. note::
``libmambapy`` is dynamically linking against ``libmamba`` (shared) library
Build ``mamba``
===============
@ -146,6 +203,9 @@ You need to build and install ``libmambapy``, which is a dependency of ``mamba``
.. code::
pip install -e ./mamba/ --no-deps
.. note::
Other dependencies are already installed from the `environment-dev.yml` file
Build ``micromamba``
====================
@ -153,38 +213,7 @@ Build ``micromamba``
Dynamically linked
******************
To build ``micromamba``, just activate the ``BUILD_MICROMAMBA`` flag in ``cmake`` command:
.. code:: bash
mkdir -p build
cd build
cmake .. \
-BUILD_MICROMAMBA=ON
make
.. note::
If you need to install the executable, use your current development environment:
- ``-DCMAKE_INSTALL_PREFIX=$CONDA_PREFIX`` [unix]
- ``-DCMAKE_INSTALL_PREFIX=$CONDA_PREFIX\\Library`` [win]
| Doing so, you have built the dynamically linked version of ``micromamba``.
| It's well fitted for development but is not the artifact shipped when installing ``micromamba`` because it still requires the dependencies shared libraries to work.
Statically linked
*****************
``micromamba`` is a fully statically linked executable. To build it, you need to install extra requirements:
.. code::
micromamba install --name <env_name> --file ./micromamba/environment-static-dev.yml
It will install the development version of dependencies, including static libraries.
Now you can run ``cmake`` with the additional flag ``MICROMAMBA_STATIC_LINK`` turned on:
To build ``micromamba``, activate the ``BUILD_MICROMAMBA`` flag in ``cmake`` command:
.. code:: bash
@ -192,7 +221,102 @@ Now you can run ``cmake`` with the additional flag ``MICROMAMBA_STATIC_LINK`` tu
cd build
cmake .. \
-DBUILD_MICROMAMBA=ON \
-DMICROMAMBA_STATIC_LINK=ON
-DMICROMAMBA_LINKAGE=DYNAMIC
make
or rebuild ``libmamba`` in the same time:
.. code:: bash
mkdir -p build
cd build
cmake .. \
-DBUILD_LIBMAMBA=ON \
-DBUILD_SHARED=ON \
-DCMAKE_INSTALL_PREFIX=$CONDA_PREFIX \
-DBUILD_MICROMAMBA=ON \
-DMICROMAMBA_LINKAGE=DYNAMIC
make
.. note::
If you need to install, use the ``CMAKE_INSTALL_PREFIX`` ``cmake`` option to point your current development environment:
- ``-DCMAKE_INSTALL_PREFIX=$CONDA_PREFIX`` [unix]
- ``-DCMAKE_INSTALL_PREFIX=$CONDA_PREFIX\\Library`` [win]
.. note::
``micromamba`` will be dynamically linked against ``libmamba`` and all its dependencies (``libsolv``, ``libarchive``, etc.)
.. note::
``MICROMAMBA_LINKAGE`` default value is ``DYNAMIC``
Statically linked
*****************
You can also build ``micromamba`` statically linked against ``libmamba``:
.. code:: bash
mkdir -p build
cd build
cmake .. \
-DBUILD_MICROMAMBA=ON \
-DMICROMAMBA_LINKAGE=STATIC
make
or with ``libmamba``:
.. code:: bash
mkdir -p build
cd build
cmake .. \
-DBUILD_LIBMAMBA=ON \
-DBUILD_STATIC=ON \
-DCMAKE_INSTALL_PREFIX=$CONDA_PREFIX \
-DBUILD_MICROMAMBA=ON \
-DMICROMAMBA_LINKAGE=STATIC
make
.. note::
``MICROMAMBA_LINKAGE`` default value is ``DYNAMIC``
.. note::
``micromamba`` will be then statically linked against ``libmamba`` but still dynamically linked against all its dependencies (``libsolv``, ``libarchive``, etc.)
Fully statically linked
***********************
``micromamba`` can be built as a fully statically linked executable. For that, you need to install extra requirements:
.. code::
micromamba install --name <env_name> --file ./micromamba/environment-static-dev.yml
It will install the development version of dependencies, including static libraries.
Now you can run ``cmake`` with the additional flag ``MICROMAMBA_STATIC_DEPS`` turned on:
.. code:: bash
mkdir -p build
cd build
cmake .. \
-DBUILD_MICROMAMBA=ON \
-DMICROMAMBA_LINKAGE=FULL_STATIC
make
or with ``libmamba``:
.. code:: bash
mkdir -p build
cd build
cmake .. \
-DBUILD_LIBMAMBA=ON \
-DBUILD_STATIC_DEPS=ON \
-DBUILD_MICROMAMBA=ON \
-DMICROMAMBA_LINKAGE=FULL_STATIC
make
Tests

188
libmamba/CMakeLists.txt
View File

@ -46,11 +46,15 @@ message(STATUS "libmamba binary version: v${LIBMAMBA_BINARY_VERSION}")
# Build options
# =============
option(BUILD_TESTS "Build libmamba C++ tests" OFF)
option(BUILD_SHARED "Build shared libmamba library" OFF)
option(BUILD_STATIC "Build static libmamba library" OFF)
option(BUILD_STATIC_DEPS "Build static libmamba library with static linkage to its dependencies" OFF)
option(MICROMAMBA_STATIC_LINK "" OFF)
if (BUILD_STATIC_DEPS)
add_definitions(-DLIBMAMBA_STATIC_DEPS)
endif ()
# Source files
# ============
@ -163,18 +167,143 @@ set(LIBMAMBA_HEADERS
# Targets and link
# ================
macro(libmamba_create_target target_name linkage output_name)
macro(libmamba_create_target target_name linkage deps_linkage output_name)
string(TOUPPER "${linkage}" linkage_upper)
if (NOT ${linkage_upper} MATCHES "^(SHARED|STATIC)$")
message(FATAL_ERROR "Invalid library linkage: ${linkage}")
endif ()
string(TOUPPER "${deps_linkage}" deps_linkage_upper)
if (NOT ${deps_linkage_upper} MATCHES "^(SHARED|STATIC)$")
message(FATAL_ERROR "Invalid library dependencies linkage: ${deps_linkage_upper}")
endif ()
# Output
# ======
add_library(${target_name} ${linkage_upper} ${LIBMAMBA_SOURCES} ${LIBMAMBA_HEADERS} ${LIBMAMBA_THIRD_PARTIES})
if (NOT MICROMAMBA_STATIC_LINK)
if (${deps_linkage_upper} STREQUAL "STATIC")
message(" -> Statically linking against libmamba (static) dependencies")
if (UNIX)
set(REQUIRED_STATIC_DEPS
libcurl.a
libssh2.a
libgssapi_krb5.a
libkrb5.a
libk5crypto.a
libkrb5support.a
libcom_err.a
libssl.a
libcrypto.a
libarchive.a
libiconv.a
libbz2.a
liblz4.a
libzstd.a
libz.a
liblzma.a
liblzo2.a
libsolv.a
libsolvext.a
libnghttp2.a
libyaml-cpp.a
libreproc++.a
libreproc.a
)
set(STATIC_DEPS "")
foreach(LIB ${REQUIRED_STATIC_DEPS})
set(TMP_LIB "${LIB}-NOTFOUND")
find_library(TMP_LIB
NAMES "${LIB}"
)
list(APPEND STATIC_DEPS "${TMP_LIB}")
endforeach(LIB)
if (APPLE)
find_library(SECURITY_LIBRARY Security)
find_library(COREFOUNDATION_LIBRARY CoreFoundation)
message("Found library: ${SECURITY_LIBRARY}\n${COREFOUNDATION_LIBRARY}")
list(APPEND STATIC_DEPS ${COREFOUNDATION_LIBRARY} ${SECURITY_LIBRARY})
endif()
message(" -> Found static dependencies:")
foreach(LIB ${STATIC_DEPS})
message(" - ${LIB}")
endforeach(LIB)
if (APPLE)
set (MAMBA_FORCE_DYNAMIC_LIBS resolv)
target_link_options(libmamba-full-static PRIVATE -static-libstdc++)
elseif (UNIX)
set(MAMBA_FORCE_DYNAMIC_LIBS rt dl resolv)
target_link_options(libmamba-full-static PUBLIC -static-libstdc++ -static-libgcc)
endif()
target_link_libraries(libmamba-full-static PUBLIC ${STATIC_DEPS} ${MAMBA_FORCE_DYNAMIC_LIBS})
elseif (WIN32)
set(CMAKE_PREFIX_PATH "$ENV{VCPKG_ROOT}/installed/x64-windows-static/")
# For Windows we have a vcpkg based build system right now.
find_package(LibArchive REQUIRED)
find_package(CURL CONFIG REQUIRED)
find_package(yaml-cpp CONFIG REQUIRED)
find_package(nlohmann_json CONFIG REQUIRED)
find_package(LibLZMA CONFIG REQUIRED)
find_library(LZ4_LIBRARY NAMES lz4)
find_library(LZO2_LIBRARY NAMES lzo2)
find_package(zstd CONFIG REQUIRED)
find_library(BZIP2_LIBRARIES NAMES bz2)
find_library(CRYPTO_LIBRARIES NAMES libcrypto)
find_library(LIBSOLV_BUILD_STATICRARIES NAMES solv_static)
find_library(LIBSOLVEXT_BUILD_STATICRARIES NAMES solvext_static)
find_package(reproc++ CONFIG REQUIRED)
find_library(LIBXML2_LIBRARY NAMES libxml2)
find_library(ICONV_LIBRARY NAMES libiconv)
find_library(CHARSET_LIBRARY NAMES libcharset)
message("Found: ${LIBXML2_LIBRARY} ${ICONV_LIBRARY} ${CHARSET_LIBRARY}")
target_link_libraries(${target_name} PRIVATE
${CRYPTO_LIBRARIES}
${LibArchive_LIBRARY}
${LIBXML2_LIBRARY}
${ICONV_LIBRARY}
${CHARSET_LIBRARY}
libzstd
${LZ4_LIBRARY}
${LZO2_LIBRARY}
${BZIP2_LIBRARIES}
${LIBLZMA_LIBRARIES}
CURL::libcurl
nlohmann_json::nlohmann_json
${YAML_CPP_LIBRARIES}
${LIBSOLV_BUILD_STATICRARIES}
${LIBSOLVEXT_BUILD_STATICRARIES}
${sodium_LIBRARY_RELEASE}
reproc++
)
add_definitions("-DLIBARCHIVE_STATIC -DCURL_STATICLIB -DSOLV_BUILD_STATIC")
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
include_directories($ENV{CONDA_PREFIX}/Library/include/)
include_directories($ENV{VCPKG_ROOT}/installed/x64-windows-static/include/)
endif()
else ()
message(" -> Dynamically linking against libmamba (shared) dependencies")
find_library(LIBSOLV_LIBRARIES NAMES solv)
find_library(LIBSOLVEXT_LIBRARIES NAMES solvext)
find_package(CURL REQUIRED)
@ -196,7 +325,8 @@ macro(libmamba_create_target target_name linkage output_name)
target_link_libraries(${target_name} PUBLIC
${LIBMAMBA_LIBRARIES_DEPS}
${MAMBA_FORCE_DYNAMIC_LIBS})
endif()
endif ()
set_property(TARGET ${target_name} PROPERTY CXX_STANDARD 17)
target_include_directories(
@ -237,39 +367,51 @@ macro(libmamba_create_target target_name linkage output_name)
)
target_compile_definitions(${target_name} PUBLIC GHC_WIN_DISABLE_WSTRING_STORAGE_TYPE)
endif()
if (${linkage_upper} STREQUAL "STATIC")
find_package(nlohmann_json CONFIG REQUIRED)
find_package(Threads REQUIRED)
target_link_libraries(${target_name} PUBLIC
nlohmann_json::nlohmann_json
Threads::Threads)
endif ()
list(APPEND libmamba_targets ${target_name})
endmacro()
set(libmamba_targets "")
if (BUILD_SHARED)
message(STATUS "Building shared library libmamba")
libmamba_create_target(libmamba SHARED libmamba)
list(APPEND libmamba_targets libmamba)
message(STATUS "Adding shared libmamba target")
libmamba_create_target(libmamba SHARED SHARED libmamba)
endif ()
if (BUILD_STATIC)
message(STATUS "Building static library libmamba")
message(STATUS "Adding static libmamba target")
# On Windows, a static library should use a different output name
# to avoid the conflict with the import library of a shared one.
if (CMAKE_HOST_WIN32)
libmamba_create_target(libmamba-static STATIC libmamba_static)
libmamba_create_target(libmamba-static STATIC SHARED libmamba_static)
else ()
libmamba_create_target(libmamba-static STATIC libmamba)
libmamba_create_target(libmamba-static STATIC SHARED libmamba)
endif ()
find_package(nlohmann_json CONFIG REQUIRED)
find_package(Threads REQUIRED)
target_link_libraries(libmamba-static PUBLIC
nlohmann_json::nlohmann_json
Threads::Threads)
list(APPEND libmamba_targets libmamba-static)
endif ()
if (NOT (BUILD_SHARED OR BUILD_STATIC))
message(FATAL_ERROR "Select at least a build variant (shared/static) for libmamba")
if (BUILD_STATIC_DEPS)
message(STATUS "Adding full-static libmamba target")
if (CMAKE_HOST_WIN32)
libmamba_create_target(libmamba-full-static STATIC STATIC libmamba_full_static)
else ()
libmamba_create_target(libmamba-full-static STATIC STATIC libmamba_full_static)
endif ()
endif ()
if (NOT (BUILD_SHARED OR BUILD_STATIC OR BUILD_STATIC_DEPS))
message(FATAL_ERROR "Select at least a build variant for libmamba")
endif ()
# Tests

4
libmamba/environment-static-dev.yml
View File

@ -10,9 +10,11 @@ dependencies:
- libarchive=3.3
- krb5-static
- libsolv-static
- libopenssl-static
- zstd-static
- libnghttp2-static
- lz4-c-static
- reproc-static
- reproc-cpp
- reproc-cpp-static
- openssl 1.1.1*
- libopenssl-static 1.1.1*

18
libmamba/libmambaConfig.cmake.in
View File

@ -13,6 +13,7 @@
# libmamba_INCLUDE_DIRS - the directory containing libmamba headers
# libmamba_LIBRARY - the library for dynamic linking
# libmamba_STATIC_LIBRARY - the library for static linking
# libmamba_FULL_STATIC_LIBRARY - the library for static linking, incl. static deps
@PACKAGE_INIT@
@ -24,19 +25,24 @@ include(CMakeFindDependencyMacro)
find_dependency(nlohmann_json)
find_dependency(Threads)
if(NOT TARGET libmamba AND NOT TARGET libmamba-static)
if(NOT (TARGET libmamba OR TARGET libmamba-static OR TARGET libmamba-full-static))
include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake")
if (TARGET libmamba AND TARGET libmamba-static)
get_target_property(@PROJECT_NAME@_INCLUDE_DIR libmamba INTERFACE_INCLUDE_DIRECTORIES)
get_target_property(@PROJECT_NAME@_LIBRARY libmamba LOCATION)
if (TARGET libmamba-static)
get_target_property(@PROJECT_NAME@_STATIC_LIBRARY libmamba-static LOCATION)
elseif (TARGET libmamba)
endif ()
if (TARGET libmamba-full-static)
get_target_property(@PROJECT_NAME@_FULL_STATIC_LIBRARY libmamba-full-static LOCATION)
endif ()
if (TARGET libmamba)
get_target_property(@PROJECT_NAME@_INCLUDE_DIR libmamba INTERFACE_INCLUDE_DIRECTORIES)
get_target_property(@PROJECT_NAME@_LIBRARY libmamba LOCATION)
elseif (TARGET libmamba-static)
get_target_property(@PROJECT_NAME@_INCLUDE_DIR libmamba-static INTERFACE_INCLUDE_DIRECTORIES)
get_target_property(@PROJECT_NAME@_STATIC_LIBRARY libmamba-static LOCATION)
set(@PROJECT_NAME@_LIBRARY ${@PROJECT_NAME@_STATIC_LIBRARY})
elseif (TARGET libmamba-full-static)
get_target_property(@PROJECT_NAME@_INCLUDE_DIR libmamba-full-static INTERFACE_INCLUDE_DIRECTORIES)
set(@PROJECT_NAME@_LIBRARY ${@PROJECT_NAME@_STATIC_LIBRARY})
endif ()
endif()

4
libmamba/src/core/fetch.cpp
View File

@ -31,7 +31,7 @@ namespace mamba
return;
}
#ifdef MICROMAMBA_STATIC_LINK
#ifdef LIBMAMBA_STATIC_DEPS
CURLsslset sslset_res;
const curl_ssl_backend** available_backends;
@ -191,7 +191,7 @@ namespace mamba
}
else if (ssl_verify == "<system>")
{
#ifdef MICROMAMBA_STATIC_LINK
#ifdef LIBMAMBA_STATIC_DEPS
curl_easy_setopt(handle, CURLOPT_CAINFO, nullptr);
#endif
}

4
libmamba/tests/CMakeLists.txt
View File

@ -42,11 +42,11 @@ file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/validation_data
DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/)
target_link_libraries(test_libmamba PRIVATE GTest::GTest GTest::Main Threads::Threads)
target_link_libraries(test_libmamba PUBLIC libmamba-static)
target_link_libraries(test_libmamba PUBLIC libmamba)
set_property(TARGET test_libmamba PROPERTY CXX_STANDARD 17)
add_custom_target(test COMMAND test_libmamba DEPENDS test_libmamba)
add_executable(testing_libmamba_lock testing/lock.cpp)
target_link_libraries(testing_libmamba_lock PUBLIC libmamba-static)
target_link_libraries(testing_libmamba_lock PUBLIC libmamba)
set_property(TARGET testing_libmamba_lock PROPERTY CXX_STANDARD 17)

19
libmambapy/CMakeLists.txt
View File

@ -1,11 +1,24 @@
find_package(pybind11 REQUIRED)
# Copyright (c) 2019, QuantStack and Mamba Contributors
#
# Distributed under the terms of the BSD 3-Clause License.
#
# The full license is in the file LICENSE, distributed with this software.
include(GNUInstallDirs)
cmake_minimum_required (VERSION 3.2)
if(POLICY CMP0025)
cmake_policy(SET CMP0025 NEW)
endif()
cmake_policy(SET CMP0077 NEW)
project(libmambapy)
find_package(pybind11 REQUIRED)
find_package(libmamba REQUIRED)
pybind11_add_module(bindings
src/main.cpp
)
target_link_libraries(bindings PUBLIC pybind11::pybind11 libmamba-static)
target_link_libraries(bindings PUBLIC pybind11::pybind11 libmamba)
set_property(TARGET bindings PROPERTY CXX_STANDARD 17)
install(TARGETS bindings

158
micromamba/CMakeLists.txt
View File

@ -1,3 +1,25 @@
# Copyright (c) 2019, QuantStack and Mamba Contributors
#
# Distributed under the terms of the BSD 3-Clause License.
#
# The full license is in the file LICENSE, distributed with this software.
cmake_minimum_required (VERSION 3.2)
if(POLICY CMP0025)
cmake_policy(SET CMP0025 NEW)
endif()
cmake_policy(SET CMP0077 NEW)
project(micromamba)
# Build options
# =============
set(MICROMAMBA_LINKAGE "DYNAMIC" CACHE STRING "micromamba linkage against libraries")
# Source files
# ============
set(MICROMAMBA_SRCS
${CMAKE_CURRENT_SOURCE_DIR}/src/clean.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/config.cpp
@ -24,132 +46,22 @@ set(MICROMAMBA_HEADERS
add_executable(micromamba ${MICROMAMBA_SRCS} ${MICROMAMBA_HEADERS})
target_include_directories(
micromamba
PRIVATE $<BUILD_INTERFACE:${LIBMAMBA_INCLUDE_DIR}>
)
find_package(libmamba REQUIRED)
target_link_libraries(micromamba PRIVATE libmamba-static)
string(TOUPPER "${MICROMAMBA_LINKAGE}" linkage_upper)
if (NOT ${linkage_upper} MATCHES "^(DYNAMIC|STATIC|FULL_STATIC)$")
message(FATAL_ERROR "Invalid executable linkage: ${MICROMAMBA_LINKAGE}, should be one of { DYNAMIC, STATIC, FULL_STATIC }")
endif ()
message("Using static dependencies for micromamba: ${MICROMAMBA_STATIC_LINK}")
message(STATUS "Micromamba linkage: ${MICROMAMBA_LINKAGE}")
if (MICROMAMBA_STATIC_LINK AND UNIX)
set(UMAMBA_LIB_DEPS
libcurl.a
libssh2.a
libgssapi_krb5.a
libkrb5.a
libk5crypto.a
libkrb5support.a
libcom_err.a
libssl.a
libcrypto.a
libarchive.a
libiconv.a
libbz2.a
liblz4.a
libzstd.a
libz.a
liblzma.a
liblzo2.a
libsolv.a
libsolvext.a
libnghttp2.a
libyaml-cpp.a
libreproc++.a
libreproc.a
)
set(FINAL_LIBS "")
foreach(LIB ${UMAMBA_LIB_DEPS})
set(TMP_LIB "TMP_LIB-NOTFOUND")
find_library(TMP_LIB
NAMES "${LIB}"
)
list(APPEND FINAL_LIBS "${TMP_LIB}")
endforeach(LIB)
if (APPLE)
find_library(SECURITY_LIBRARY Security)
find_library(COREFOUNDATION_LIBRARY CoreFoundation)
message("Found library: ${SECURITY_LIBRARY}\n${COREFOUNDATION_LIBRARY}")
list(APPEND FINAL_LIBS ${COREFOUNDATION_LIBRARY} ${SECURITY_LIBRARY})
endif()
message(" Found static dependencies:")
foreach(LIB ${FINAL_LIBS})
message(" - ${LIB}")
endforeach(LIB)
if (APPLE)
set (MAMBA_FORCE_DYNAMIC_LIBS resolv)
target_link_options(micromamba PRIVATE -static-libstdc++)
elseif (UNIX)
set(MAMBA_FORCE_DYNAMIC_LIBS rt dl resolv)
target_link_options(micromamba PRIVATE -static-libstdc++ -static-libgcc)
endif()
target_link_libraries(micromamba PRIVATE ${FINAL_LIBS} ${MAMBA_FORCE_DYNAMIC_LIBS})
elseif (MICROMAMBA_STATIC_LINK AND WIN32)
set(CMAKE_PREFIX_PATH "$ENV{VCPKG_ROOT}/installed/x64-windows-static/")
# For Windows we have a vcpkg based build system right now.
find_package(LibArchive REQUIRED)
find_package(CURL CONFIG REQUIRED)
find_package(yaml-cpp CONFIG REQUIRED)
find_package(nlohmann_json CONFIG REQUIRED)
find_package(LibLZMA CONFIG REQUIRED)
find_library(LZ4_LIBRARY NAMES lz4)
find_library(LZO2_LIBRARY NAMES lzo2)
find_package(zstd CONFIG REQUIRED)
find_library(BZIP2_LIBRARIES NAMES bz2)
find_library(CRYPTO_LIBRARIES NAMES libcrypto)
find_library(LIBSOLV_BUILD_STATICRARIES NAMES solv_static)
find_library(LIBSOLVEXT_BUILD_STATICRARIES NAMES solvext_static)
find_package(reproc++ CONFIG REQUIRED)
find_library(LIBXML2_LIBRARY NAMES libxml2)
find_library(ICONV_LIBRARY NAMES libiconv)
find_library(CHARSET_LIBRARY NAMES libcharset)
message("Found: ${LIBXML2_LIBRARY} ${ICONV_LIBRARY} ${CHARSET_LIBRARY}")
target_link_libraries(micromamba PRIVATE
${CRYPTO_LIBRARIES}
${LibArchive_LIBRARY}
${LIBXML2_LIBRARY}
${ICONV_LIBRARY}
${CHARSET_LIBRARY}
libzstd
${LZ4_LIBRARY}
${LZO2_LIBRARY}
${BZIP2_LIBRARIES}
${LIBLZMA_LIBRARIES}
CURL::libcurl
nlohmann_json::nlohmann_json
${YAML_CPP_LIBRARIES}
${LIBSOLV_BUILD_STATICRARIES}
${LIBSOLVEXT_BUILD_STATICRARIES}
${sodium_LIBRARY_RELEASE}
reproc++
)
add_definitions("-DLIBARCHIVE_STATIC -DCURL_STATICLIB -DSOLV_BUILD_STATIC")
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
include_directories($ENV{CONDA_PREFIX}/Library/include/)
include_directories($ENV{VCPKG_ROOT}/installed/x64-windows-static/include/)
endif()
if (${MICROMAMBA_LINKAGE} STREQUAL "FULL_STATIC")
target_link_libraries(micromamba PRIVATE libmamba-full-static)
elseif (${MICROMAMBA_LINKAGE} STREQUAL "STATIC")
target_link_libraries(micromamba PRIVATE libmamba-static)
else ()
target_link_libraries(micromamba PRIVATE libmamba)
endif ()
set_property(TARGET micromamba PROPERTY CXX_STANDARD 17)