Skip to content

Latest commit

 

History

History
155 lines (124 loc) · 5.17 KB

README.md

File metadata and controls

155 lines (124 loc) · 5.17 KB
Raw

Dopamine package manager

Package manager for compiled languages.

Dopamine PM is a tool for developers that helps to download and build dependencies in a predictible way.

Dopamine is still under development and cannot be used yet in production.

Goals

  • Ease interoperability of C / C++ / D
  • Build-system agnosticity
  • Highly flexible package recipe
  • Consume DUB packages as dependency
  • Drop-in replacement of dub client
  • Ease to package 3rdparty code without patching (packages not aware of Dopamine)
  • Allows to look-up for system-installed dependency before downloading and build
  • Lock dependency versions for deterministic dependencies
  • Reduce compilation time by uploading/downloading pre-built packages

Design

  • The dop command line tool provide commands for all aspects of building and packaging.

    • Setup compilation profile
    • Get the source
    • Resolve and lock dependencies
    • Build (using the build system provided by the source package)
    • Package/publish
    • Upload a build
    • See the client spec for more details.

  • Recipes are Lua scripts.

    • Recipes provide some descriptive fields and functions for:
      • package metadata
      • downloading source (if the source is not packaged with the recipe)
      • patch (if needed)
      • build
    • Most of recipes tasks are helped by a comprehensive dop lua library, pre-loaded by the client.
    • Thanks to Lua's functional flexibility, most recipes can look purely declarative

  • Dependencies are resolved with a DAG. See dag.d.

  • Compilation profiles are saved in INI files, that can be saved user-wide and reused at will

    • The dop client provide helpers to edit them, but can also be done by hand.
    • Each profile gets a unique identifier based on the build options, platform, compilers versions and ABI etc.

  • Everything that can alter the build (profile id, resolved dependencies versions...) is reduced to a unique build identifier.

    • This identifier allows to upload a built package
    • A consumer can consume this pre-built package as dependency if the same ID is computed.
    • If no build is found, the recipe is used to build the package (and optionally upload it after the build).

  • A part of the design is inspired by conan

Example of Recipe

Here is an example of recipe that would build and package libpng. Because it is packaging a 3rd party library, it has to download the source, and perform a few adjustement in the build options.

name = 'libpng'
version = '1.6.37'
description = 'The PNG reference library'
authors = {'The PNG Reference Library Authors'}
license = 'http://www.libpng.org/pub/png/src/libpng-LICENSE.txt'
copyright = 'Copyright (c) 1995-2019 The PNG Reference Library Authors'
tools = {'cc'}

dependencies = {zlib = '>=1.2.5'}

function source()
    local folder = 'libpng-' .. version
    local archive = folder .. '.tar.xz'
    dop.download {
        'https://download.sourceforge.net/libpng/' .. archive,
        dest = archive,
    }
    dop.checksum {
        archive,
        sha256 = '505e70834d35383537b6491e7ae8641f1a4bed1876dbfe361201fc80868d88ca',
    }
    dop.extract_archive { archive, outdir = '.' }

    return folder
end

function build(dirs, config, dep_infos)

    local cmake = dop.CMake:new(config.profile)

    local defs = {
        ['PNG_TESTS'] = false,
    }
    -- if zlib is not in the system but in the dependency cache
    if dep_infos and dep_infos.zlib then
        local zlib = dep_infos.zlib.install_dir
        local libname = dop.windows and 'zlibstatic' or 'z'
        defs['ZLIB_INCLUDE_DIR'] = dop.path(zlib, 'include')
        defs['ZLIB_LIBRARY'] = dop.find_libfile(dop.path(zlib, 'lib'), libname, 'static')
    end

    cmake:configure({
        src_dir = dirs.src,
        install_dir = dirs.install,
        defs = defs,
    })
    cmake:build()
    cmake:install()
end

Build dopamine

Dopamine is developed and built with meson. You need the following tools:

  • meson (>= 0.63)
  • ninja
  • a D compiler (either DMD or LDC)
  • Dub (dopamine depends on vibe-d)
  • a C compiler
    • C libraries are compiled if not found on the system (Lua + compression libraries)

Linux

DC=ldc meson setup build-ldc
cd build-ldc
ninja # or meson compile
ninja test # or meson test

# you can now run the dop client
packages/client/dop -h

Windows

Windows is always more complex to setup. Only MSVC is supported as C compiler, as D compilers do not link to MingW out of the box. Also you need to run both meson and ninja from a VS prompt. If you have [vswhere](https://github.com/microsoft/vswhere) in your Path, win_env_vs.bat is provided to setup the VS environment from your regular CMD prompt (do not work with powershell). Alternatively, the modern Windows Terminal app is also helpful.

win_env_vs.bat
rem Windows is so slow to compile, you are better off with a fast D compiler
set DC=dmd
meson setup build-dmd
cd build-dmd
ninja rem or meson compile
ninja test rem or meson test

rem you can now run the dop client
packages\client\dop.exe -h