drakefile

import drake
import drake.cxx
import drake.debian
import drake.docker
import drake.gRPC
import drake.git
import drake.go
import drake.license_file
import drake.python
import drake.redhat
import drake.valgrind

import os
import re
import shutil

from itertools import chain

git = None

elle = None

cxx_config = None
cli_cxx_config = None
cxx_config_tests = None
cxx_toolkit = None
grpc = None

lib = None
cli_lib = None
grpc_libs = None

prometheus = None
# The installed executables: bin/memo.
installed_binaries = []

# //build: Build libraries and binaries.
rule_build = None
# //tests: Build tests.
rule_tests = None
# //check: Build and run tests.
rule_check = None
# //install: Install binaries under <prefix>.
rule_install = None
# //symbols: prepare the symbol files for crash reports.
rule_symbols = None

description_regex = '^.{0,2048}$'
email_regex = '^[^@]+@[^@]+\.[^@]+$'
name_regex = '^[-a-z0-9_][-a-z0-9._]{0,127}$'

beyond_delegate_user = 'hub'

license_file = None

def set_cxx_config(config):
  global cxx_config
  cxx_config = config

def set_cxx_toolkit(toolkit):
  global cxx_toolkit
  cxx_toolkit = toolkit

with open(str(drake.path_source('elle/drake-utils.py')), 'r') as f:
  exec(f.read(), globals(), globals())

def configure(
    cxx_toolkit = None,
    cxx_config = drake.cxx.Config(),
    production_build = False,
    entreprise_edition : bool = True,
    beyond_host = 'https://beyond.infinit.sh',
    boost = None,
    prefix = '/usr',
    valgrind = None,
    valgrind_tests = False,
    python = None,
    python3 = None, # Alias for python
    fuse = None,
    codesign = False,
    beyond: bool = True,
    enable_crash_report: bool = True,
    cxx_toolkit_host = None,
    go_toolkit = None,
    go_config = drake.go.Config()
):
  if python3 is not None:
    python = python3

  global rule_build, rule_check, rule_install, rule_symbols, rule_tests
  rule_build = drake.Rule('build')
  rule_check = drake.Rule('check')
  rule_install = drake.Rule('install')
  rule_symbols = drake.Rule('symbols')
  rule_tests = drake.Rule('tests')
  rule_functional_tests = drake.Rule('functional/tests')
  rule_functional_check = drake.Rule('functional/check')

  prefix = drake.Path(prefix)
  if prefix.relative:
    prefix = drake.path_build(prefix, absolute = True)

  cxx_config = drake.cxx.Config(cxx_config)
  cxx_config.warnings.parentheses = False
  cxx_config.warnings.sign_compare = drake.cxx.Config.Warnings.Error;
  if production_build:
    cxx_config.enable_optimization()
    cxx_config.define('MEMO_PRODUCTION_BUILD')

  global git
  git = drake.git.Git()

  global elle
  elle = drake.include('elle',
                       production_build = production_build,
                       cxx_toolkit = cxx_toolkit,
                       cxx_toolkit_host = cxx_toolkit_host,
                       cxx_config = cxx_config,
                       python3 = python,
                       fuse = fuse,
                       valgrind = valgrind,
                       prefix = False,
                       codesign = codesign)
  windows = elle.cxx_toolkit.os is drake.os.windows
  linux = elle.cxx_toolkit.os is drake.os.linux
  # Where we install libraries.
  libdir = 'bin' if windows else 'lib'

  def copy_library(library, *a, **kw):
    return drake.copy(library, libdir, *a, strip_prefix = True, **kw)

  def import_lib(lib):
    return copy_library(lib.lib_dynamic)

  athena_lib       = import_lib(elle.athena)
  aws_lib          = import_lib(elle.aws)
  cryptography_lib = import_lib(elle.cryptography)
  dropbox_lib      = import_lib(elle.dropbox)
  elle_lib         = import_lib(elle.elle)
  protocol_lib     = import_lib(elle.protocol)
  reactor_lib      = import_lib(elle.reactor)

  # macOS's libc++.
  dokan_lib = elle.reactor.dokan_lib if windows else None

  cxx_toolkit = elle.cxx_toolkit
  set_cxx_toolkit(cxx_toolkit)
  cxx_config += elle.config
  cxx_config += elle.dropbox.config
  cxx_config += elle.athena.config
  cxx_config.add_local_include_path('src')
  cxx_config.define('_FILE_OFFSET_BITS=64')

  if cxx_toolkit.os == drake.os.linux:
    cxx_config.define('ELLE_LINUX')
  elif cxx_toolkit.os == drake.os.android:
    cxx_config.define('ELLE_ANDROID')
  elif cxx_toolkit.os == drake.os.macos:
    cxx_config.define('ELLE_MACOS')
  elif cxx_toolkit.os == drake.os.windows:
    cxx_config.define('ELLE_WINDOWS')
  elif cxx_toolkit.os is drake.os.ios:
    cxx_config.define('ELLE_IOS')

  if cxx_toolkit.os in [drake.os.macos] and cxx_toolkit.kind == drake.cxx.GccToolkit.Kind.clang:
    cxx_config.use_local_libcxx = True

  set_cxx_config(cxx_config)
  set_cxx_toolkit(cxx_toolkit)

  # Go.
  if go_toolkit is None:
    go_toolkit = drake.go.Toolkit(
      path = os.path.realpath(str(drake.path_build('go-dependencies'))),
      cxx_toolkit = cxx_toolkit,
    )

  PatchAndInstall = drake.cxx.PatchAndInstall

  ## ------ ##
  ## grpc.  ##
  ## ------ ##

  global grpc
  grpc_cxx_config = drake.cxx.Config(cxx_config)
  grpc_cxx_config += elle.boost.config_system(link = False)
  grpc_cxx_config.library_add(copy_library(elle.boost.system_dynamic))
  grpc = drake.include(
    'src/memo/grpc',
    libs = [elle_lib, protocol_lib, reactor_lib, cryptography_lib],
    libdir = drake.Path('../../..') / libdir,
    cxx_toolkit = cxx_toolkit,
    cxx_config = grpc_cxx_config)

  grpc_lib = copy_library(grpc.lib, builder = PatchAndInstall)
  protobuf_lib = copy_library(grpc.protobuf_lib, builder = PatchAndInstall)
  global grpc_libs
  grpc_libs = [grpc_lib, protobuf_lib]

  ## -------------- ##
  ## Crash report.  ##
  ## -------------- ##

  if windows:
    enable_crash_report = False
  if enable_crash_report:
    crash_report = drake.include('crash-report',
                                 cxx_toolkit = cxx_toolkit,
                                 cxx_config = cxx_config)
    crash_report_lib = import_lib(crash_report)
    minidump_stackwalk = crash_report.minidump_stackwalk_exe
    cxx_config.define('MEMO_ENABLE_CRASH_REPORT')
    cxx_config.add_local_include_path('crash-report/src')
  else:
    minidump_stackwalk = None

  ## --------------- ##
  ## Infinit library ##
  ## --------------- ##

  cxx_config = drake.cxx.Config(cxx_config)

  cxx_config += elle.boost.config_system(link = False)
  cxx_config.library_add(copy_library(elle.boost.system_dynamic))
  cxx_config += elle.boost.config_filesystem(link = False)
  cxx_config.library_add(copy_library(elle.boost.filesystem_dynamic))
  cxx_config += elle.das.config

  class CxxVersionGenerator(VersionGenerator):
    def _variable(self, name, value):
      try:
        return '#define MEMO_%s %s' % (name.upper(), int(value))
      except:
        return '#define MEMO_%s "%s"' % (name.upper(), value)

  def stringify(s):
    return '"%s"' % re.sub(r'([\\"])', r'\\\1', s)

  CxxVersionGenerator(drake.node('src/memo/version.hh'),
                      git,
                      production_build = production_build)

  with drake.templating.Context(content = {
      'description_regex': description_regex,
      'name_regex': name_regex,
    }):
    drake.node('src/memo/descriptor/TemplatedBaseDescriptor.hxx.tmpl')

  memo_sources = drake.nodes(
    'src/memo/Hub.cc',
    'src/memo/Hub.hh',
    'src/memo/KeyValueStore.cc',
    'src/memo/KeyValueStore.hh',
    'src/memo/LoginCredentials.cc',
    'src/memo/LoginCredentials.hh',
    'src/memo/Memo.cc',
    'src/memo/Memo.hh',
    'src/memo/Memo.hxx',
    'src/memo/MountOptions.cc',
    'src/memo/MountOptions.hh',
    'src/memo/Network.cc',
    'src/memo/Network.hh',
    'src/memo/RPC.cc',
    'src/memo/RPC.hh',
    'src/memo/RPC.hxx',
    'src/memo/User.cc',
    'src/memo/User.hh',
    'src/memo/Version.hh',
    'src/memo/crash-report.cc',
    'src/memo/crash-report.hh',
    'src/memo/environ.cc',
    'src/memo/environ.hh',
    'src/memo/log.cc',
    'src/memo/log.hh',
    'src/memo/serialization.cc',
    'src/memo/serialization.hh',
    'src/memo/utility.hh',
    'src/memo/version.hh',
  )
  memo_sources += drake.include('src/memo/credentials').sources
  memo_sources += drake.include('src/memo/descriptor').sources
  memo_sources += drake.include('src/memo/filesystem').sources
  memo_sources += drake.include('src/memo/model').sources
  memo_sources += drake.include('src/memo/overlay').sources
  memo_sources += drake.include(
    'src/memo/silo',
    entreprise_edition = entreprise_edition).sources
  memo_utility_config = drake.cxx.Config(cxx_config)
  memo_utility_config.define('BEYOND_HOST', stringify(beyond_host))
  memo_utility_config.define('BEYOND_DELEGATE_USER',
                                stringify(beyond_delegate_user))
  memo_utility_config.define('EMAIL_REGEX', stringify(email_regex))
  memo_sources.append(
    drake.cxx.Object(
      drake.node('src/memo/utility.cc'),
      cxx_toolkit,
      memo_utility_config))
  if not windows:
    memo_sources += drake.nodes(
      'src/memo/silo/sftp.cc',
      'src/memo/silo/sftp.hh',
    )
  outguess_lib = drake.cxx.StaticLib('src/memo/model/steg/outguess-0.2/outguess.a')
  jpeg_lib = drake.cxx.StaticLib('src/memo/model/steg/outguess-0.2/jpeg-6b-steg/libjpeg.a')

  outguess_configure = drake.node('src/memo/model/steg/outguess-0.2/configure')
  outguess_makefile = drake.node('src/memo/model/steg/outguess-0.2/Makefile')

  cxx_config += grpc.grpc.cxx_config
  extra_libs = []

  ## ------------ ##
  ## Prometheus.  ##
  ## ------------ ##
  enable_prometheus = not windows
  if enable_prometheus:
    cxx_config.define('MEMO_ENABLE_PROMETHEUS', '1')
    global prometheus
    prometheus = drake.include('prometheus/prometheus-cpp',
                               cxx_toolkit = cxx_toolkit,
                               in_cxx_config = cxx_config,
                               protoc = grpc.grpc.protoc,
                               protobuf_config = grpc.grpc.cxx_config,
                               protobuf_lib = grpc.grpc.protobuf_lib)
    cxx_config += prometheus.cxx_config
    prometheus_lib = copy_library(prometheus.prometheus_lib)
    extra_libs.append(prometheus_lib)
    drake.node('src/memo/model/prometheus.hh')\
         .dependencies_add(grpc.grpc.protobuf_headers
                           + drake.nodes('prometheus/prometheus-cpp/lib/cpp/metrics.pb.h'))

  ## --------- ##
  ## libmemo.  ##
  ## --------- ##

  libtype = drake.cxx.DynLib
  if windows:
    cxx_config.lib('shlwapi')
    cxx_config.lib('ws2_32')
    cxx_config.lib('gdi32')
    cxx_config.lib('mswsock')
    cxx_config.lib('dbghelp')
    cxx_config.lib('iphlpapi')
    cxx_config.lib('crypt32')
    extra_libs += [copy_library(dokan_lib)]
    cxx_config.use_whole_archive()

  if elle.boost.prefer_shared:
    cxx_config.library_add(copy_library(elle.boost.regex_dynamic))
  else:
    cxx_config.library_add(elle.boost.regex_static)

  global lib
  lib = libtype(
    libdir + '/memo',
    (memo_sources
     + [athena_lib,
        cryptography_lib,
        aws_lib,
        protocol_lib,
        dropbox_lib,
        reactor_lib,
        elle_lib,
     ]
     + extra_libs
     + ([crash_report_lib] if enable_crash_report else [])),
    cxx_toolkit,
    cxx_config,
    strip = windows)
  rule_build << lib

  ## ----- ##
  ## kvs.  ##
  ## ----- ##

  # XXX: Go cross compiling requires go > 1.6 (tested with 1.8.3).
  # XXX: Re-enable key-value store for Windows when the build farm has been
  # XXX: updated.
  #
  # FIXME: on alpine the libc does not allow us to share
  # argc/argv/envp/auxp with the go runtime.  So libkvs is broken, and
  # memo cannot even start.
  try:
    with open('/etc/motd', 'r') as f:
      alpine = 'Alpine' in f.read()
  except:
    alpine = False

  with_kvs = not windows and not alpine

  if with_kvs:
    kvs = drake.include(
      'src/memo/kvs',
      go_toolkit = go_toolkit,
      go_config = go_config,
      grpc = grpc,
    )
    lib_kvs = copy_library(kvs.library)

  ## ------ ##
  ## gRPC.  ##
  ## ------ ##
  memo_vs_grpc_lib = drake.cxx.DynLib(
    libdir + '/memo_grpc',
    grpc.memo_vs_sources + grpc_libs + [lib] + [
      elle_lib, reactor_lib, cryptography_lib,
    ],
    cxx_toolkit,
    cxx_config)
  grpc_libs += [memo_vs_grpc_lib]

  ## -------- ##
  ## Binaries ##
  ## -------- ##

  def cpp_str_escape(string):
    from json import dumps
    return dumps(string).strip('"')

  global cli_cxx_config
  cli_cxx_config = drake.cxx.Config(cxx_config)
  cli_cxx_config += elle.das.config
  cli_cxx_config += grpc.grpc.cxx_config

  # Needed for Prometheus.
  if enable_prometheus:
    cli_cxx_config += prometheus.cxx_config

  cli_cxx_config.lib_path_runtime('../lib')
  cli_cxx_config.library_add(copy_library(elle.boost.program_options_dynamic))
  cli_cxx_config.library_add(copy_library(elle.boost.filesystem_dynamic))
  cli_cxx_config.library_add(copy_library(elle.boost.regex_dynamic))
  cli_cxx_config.library_add(copy_library(elle.boost.system_dynamic))
  if cxx_toolkit.os is drake.os.macos:
    cli_cxx_config.framework_add('CoreServices')
    cli_cxx_config.ldflag('-headerpad_max_install_names')
  if cxx_toolkit.os is drake.os.windows:
    cli_cxx_config.lib('shlwapi')
    cli_cxx_config.lib('ws2_32')
    cli_cxx_config.lib('gdi32')
    cli_cxx_config.lib('mswsock')
    cli_cxx_config.lib('dbghelp')
    cli_cxx_config.lib('iphlpapi')
    cli_cxx_config.lib('crypt32')
    cli_cxx_config.lib('winmm')
    cli_cxx_config.library_add(
      drake.copy(dokan_lib, libdir, True))
  if with_kvs:
    cli_cxx_config.library_add(lib_kvs)
  if entreprise_edition:
    cli_cxx_config.define('MEMO_ENTREPRISE_EDITION')

  with_daemon = (cxx_toolkit.os is drake.os.linux) or \
                (production_build is False and cxx_toolkit.os is drake.os.macos)
  #  _____ _____  ____  __ _____
  # |  ___|_ _\ \/ /  \/  | ____|
  # | |_   | | \  /| |\/| |  _|
  # |  _|  | | /  \| |  | | |___
  # |_|   |___/_/\_\_|  |_|_____|
  #
  # XXX / FIXME: Daemon is disabled for now.
  with_daemon = False
  cli_cxx_config.define('MEMO_WITH_DAEMON', '1' if with_daemon else '0')
  cli_cxx_config.define('MEMO_WITH_KEY_VALUE_STORE', '1' if with_kvs else '0')
  binaries = []
  global installed_binaries
  installed_binaries = []
  installed_symbols = []
  debian_debug_dir = 'debian-debug'
  debian_syms_dir = \
    drake.path_build('%s/opt/memp/lib/memo/debug' % debian_debug_dir)
  installed_libraries = set()
  # CLI
  cli_sources = drake.nodes(
    'src/memo/cli/Block.cc',
    'src/memo/cli/Block.hh',
    'src/memo/cli/Credentials.cc',
    'src/memo/cli/Credentials.hh',
    'src/memo/cli/Device.cc',
    'src/memo/cli/Device.hh',
    'src/memo/cli/Doctor.cc',
    'src/memo/cli/Doctor.hh',
    'src/memo/cli/Error.hh',
    'src/memo/cli/Memo.cc',
    'src/memo/cli/Memo.hh',
    'src/memo/cli/Memo.hxx',
    'src/memo/cli/Journal.cc',
    'src/memo/cli/Journal.hh',
    'src/memo/cli/Network.cc',
    'src/memo/cli/Network.hh',
    'src/memo/cli/Object.hh',
    'src/memo/cli/Object.hxx',
    'src/memo/cli/Passport.cc',
    'src/memo/cli/Passport.hh',
    'src/memo/cli/Silo.cc',
    'src/memo/cli/Silo.hh',
    'src/memo/cli/User.cc',
    'src/memo/cli/User.hh',
    'src/memo/cli/utility.cc',
    'src/memo/cli/utility.hh',
    'src/memo/cli/xattrs.cc',
    'src/memo/cli/xattrs.hh',
  )
  memo_modes = [
      'block',
      'credentials',
      'device',
      'doctor',
      'journal',
      'network',
      'passport',
      'silo',
      'user',
  ]
  if with_kvs:
    cli_sources += drake.nodes(
      'src/memo/cli/KeyValueStore.cc',
      'src/memo/cli/KeyValueStore.hh',
    )
    memo_modes.append('key-value-store')
  if with_daemon:
    memo_modes.append('daemon')
    cli_sources += drake.nodes(
      'src/memo/cli/Daemon.cc',
      'src/memo/cli/Daemon.hh',
    )
  cli_instantiate = drake.node(
    'src/memo/cli/memo-instantiate.cc')
  for b in memo_modes:
    cli_instantiate_config = drake.cxx.Config(cli_cxx_config)
    if windows:
      cli_instantiate_config.define('ELLE_LOG_DISABLE', 1)
    cli_sources.append(
      drake.cxx.Object(
        drake.node('src/memo/cli/instantiate-%s.cc' % b.replace('_', '-')),
        cxx_toolkit,
        cli_instantiate_config))

  cli_deps = [lib] + extra_libs + grpc_libs
  # Do not relink with the static libs again under windows
  # they are allready whole_archive-d into `lib`.
  cli_deps += [
    aws_lib,
    cryptography_lib,
    elle_lib,
    protocol_lib,
    reactor_lib,
  ]
  if enable_prometheus:
    cli_deps.append(prometheus_lib)
  if enable_crash_report:
    cli_deps.append(crash_report_lib)

  # Ship libstdc++ and libgcc_s.
  additional_libs = []
  if linux and cxx_toolkit.architecture is not drake.architecture.arm:
    # On alpine, libgcc.so is not a symlink to the real library, rather
    # it's a small text file:
    #
    # bash-4.3# cat /usr/lib/libgcc_s.so
    # /* GNU ld script
    #    Use the shared library, but some functions are only in
    #    the static library.  */
    # GROUP ( libgcc_s.so.1 -lgcc )
    #
    # so bringing it does not help us.  Rather that explicitly looking
    # for these names, one would prefer to run `ldd` on the binaries
    # (say bin/memo) and look for the dependencies, unfortunately this
    # would be done at Drake build-time, during which it is already
    # too late to build these nodes.  So we encode the names here.
    #
    # On the other architectures (Jessie, Xenial), the names without
    # version do fine.
    for l in ['libstdc++.so.6', 'libgcc_s.so.1']:
      cmd = [cxx_toolkit.cxx] \
            + cxx_toolkit.cflags(cli_cxx_config) \
            + cxx_toolkit.ldflags(cli_cxx_config) \
            + ['-print-file-name={}'.format(l)]
      output = subprocess.check_output(cmd).decode('utf-8').strip()
      path = drake.Path(output)
      additional_libs.append(copy_library(drake.cxx.DynLib(path)))

  global cli_lib
  cli_lib  = libtype(
    libdir + '/memo_cli',
    cli_sources + cli_deps,
    cxx_toolkit,
    cli_cxx_config,
    strip = windows)

  cli = drake.cxx.Executable(
    'bin/memo',
    drake.nodes('src/memo/cli/Memo_main.cc',) + [cli_lib] + cli_deps,
    cxx_toolkit,
    cli_cxx_config,
    strip = windows)

  binaries.append(cli)
  installed_binaries.append(cli)
  for l in cli.dynamic_libraries:
    if l not in installed_libraries:
      installed_libraries.add(l)
  if enable_crash_report:
    for f in installed_libraries | set(installed_binaries):
      sym = drake.node('%s.sym' % f.path())
      crash_report.SymbolsGenerator(crash_report.dump_syms_exe,
                                    f, sym,
                                    cxx_toolkit = cxx_toolkit)
      installed_symbols.append(sym)
    if prefix:
      symbols_dir = '%s/%s' % (prefix, git.version())
      for s in installed_symbols:
        rule_symbols << drake.copy(s, symbols_dir, strip_prefix = True)
  rule_build << binaries

  set_cxx_config(cxx_config)
  ## -------- ##
  ## Licenses ##
  ## -------- ##

  global license_file
  license_file = drake.node('OSS-licenses')
  drake.license_file.Packager('licenses', license_file)

  ## ------- ##
  ## Install ##
  ## ------- ##

  def install_nodes(where):
    where = drake.Path(where)
    yield from drake.copy(installed_binaries, where, None,
                          builder = PatchAndInstall,
                          follow_symlinks = False)
    yield from drake.copy(
      [license_file], where / 'share/infinit/memo/licenses')

  rule_install << install_nodes(prefix)

  # man = drake.nodes(
  #   'share/man/man1/infinit.1',
  #   'share/man/man5/infinit.5',
  # )
  # rule_install << drake.install(man, prefix)

  ## ------ ##
  ## Debian ##
  ## ------ ##

  debian_nodes = install_nodes('debian/opt/memo')
  git = drake.git.Git()
  if cxx_toolkit.os is drake.os.linux:
    from platform import linux_distribution
    platform = linux_distribution()[0].lower().replace(' ', '-')
  elif cxx_toolkit.os is drake.os.macos:
    platform = 'macosx'
  else:
    platform = 'unknown'
  def make_executable(target):
    os.chmod(str(target), 0o755)
    return True
  debian_nodes = chain(
    debian_nodes,
    drake.copy(drake.nodes('debian-packaging/release/postinst'),
                           'debian/DEBIAN',
                           post_process = make_executable,
                           strip_prefix = True,
                           follow_symlinks = False),
  )
  rule_debian = drake.Rule('debian')
  if cxx_toolkit.os is drake.os.linux:
    rule_debian << drake.debian.Packager(
      'memo_%s_amd64.deb' % git.description(),
      {
        'Package': 'memo',
        'Maintainer': 'Infinit <open+memo@infinit.sh>',
        'Version': git.description(),
        'Homepage': 'https://www.infinit.sh',
        'Architecture': 'amd64',
        'Description': 'memo key-value store.',
        'Section': 'utils',
        'Priority': 'optional',
      },
      debian_nodes,
      'debian').package

  if enable_crash_report:
    # //symbols-commit: publish the debug symbols for breakpad,
    # installed on Beyond.
    symbols_commit = drake.node('//symbols-commit')
    symbols_commit_builder = crash_report.SymbolsCommit(
      symbols_commit,
      installed_symbols,
      repo = 'git@git.infinit.sh:infinit/debug-symbols.git',
      platform = platform,
      description = git.description(),
      project = 'memo')

  ## ------- ##
  ## Red Hat ##
  ## ------- ##

  redhat_version = git.description().replace('-', '_')
  redhat_rule = drake.Rule('redhat')
  redhat_build_root = 'redhat/BUILDROOT'
  redhat_nodes = list(install_nodes('%s/opt/memo' % redhat_build_root))
  def installed_files(nodes):
    def clean_path(path):
      return str(path).replace(
        '%s/' % drake.path_build(), '').replace(redhat_build_root, '')
    res = set()
    for node in nodes:
      res.add(clean_path(node))
      if isinstance(node, drake.cxx.Executable):
        for dep in node.dependencies_recursive:
          res.add(clean_path(dep))
    return sorted(list(res))

  with drake.templating.Context(content = {
      'changelog': '',
      'files': '\n'.join(installed_files(redhat_nodes)),
      'glibc_version': '2.12',
      'version': redhat_version,
  }):
    drake.node('redhat-packaging/package/memo.spec.tmpl')

  redhat_nodes = chain(
    redhat_nodes,
    drake.copy(drake.nodes('redhat-packaging/package/memo.spec'),
               'redhat/SPECS', strip_prefix = True, follow_symlinks = False),
  )

  redhat_package = drake.redhat.Packager('memo',
                                         redhat_version,
                                         'el6', 'x86_64',
                                         drake.path_build('redhat'),
                                         redhat_nodes).package
  redhat_rule << redhat_package

  redhat_repo_version = '0.1'
  with drake.templating.Context(content = {
      'base_url': 'https://yum.infinit.sh/',
      'files': '/etc/yum.repo.d/memo.repo',
      'version': redhat_repo_version,
  }):
    drake.node('redhat-packaging/repository/memo-release.spec.tmpl')
    drake.node('redhat-packaging/repository/memo.repo.tmpl')

  redhat_repo_nodes = chain(
    drake.copy(
      drake.nodes('redhat-packaging/repository/memo-release.spec'),
      'redhat-repo/SPECS', strip_prefix = True),
    drake.copy(
      drake.nodes('redhat-packaging/repository/memo.repo'),
      'redhat-repo/BUILDROOT/etc/yum.repo.d', strip_prefix = True),
  )

  redhat_repo_package = drake.redhat.Packager(
    'memo-release',
    redhat_repo_version,
    'el6', 'x86_64',
    drake.path_build('redhat-repo'),
    redhat_repo_nodes).package
  redhat_rule << redhat_repo_package

  ## ------ ##
  ## Docker ##
  ## ------ ##

  # memo image
  docker_path = drake.Path('docker')
  docker_image = drake.docker.DockerImage(
    'docker', 'memo', git.description())
  docker_file = drake.docker.DockerFile(
    docker_path / 'Dockerfile',
    image = 'ubuntu',
    maintainer = 'Infinit <open+memo@infinit.sh>',
    labels = {
      'version': git.description(),
    })
  docker_file.run('apt-get update && apt-get install -y python3')
  docker_file.add(install_nodes(docker_path), '/usr')
  drake.docker.DockerBuilder(docker_image, docker_file)

  # memo alpine image
  docker_path = drake.Path('docker-alpine')
  docker_image = drake.docker.DockerImage(
    'docker-alpine', 'memo-alpine', git.description())
  docker_file = drake.docker.DockerFile(
    docker_path / 'Dockerfile',
    image = 'alpine',
    maintainer = 'Infinit <open+memo@infinit.sh>',
    labels = {
      'version': git.description(),
    })
  docker_file.add(install_nodes(docker_path), '/usr')
  docker_file.run("apk update && apk add libgc++ && rm -rf /var/cache/apk/*")
  drake.docker.DockerBuilder(docker_image, docker_file)

  ## ------ ##
  ## Beyond ##
  ## ------ ##

  if elle.python3:
    bottle = drake.node('bottle/bottle.py')
    sendwithus = drake.python.Package(
      'sendwithus',
      'sendwithus_python',
      drake.nodes(
        'sendwithus_python/sendwithus/__init__.py',
        'sendwithus_python/sendwithus/encoder.py',
        'sendwithus_python/sendwithus/exceptions.py',
        'sendwithus_python/sendwithus/version.py',
      ),
    )
    if beyond:
      beyond = drake.include(
        'beyond',
        production_build = production_build,
        python = elle.python3,
        cryptography_python_module = elle.cryptography.python_module,
        sendwithus = sendwithus,
        prefix = prefix,
        git = git,
        bottle = bottle,
        PatchAndInstall = PatchAndInstall,
        description_regex = description_regex,
        email_regex = email_regex,
        name_regex = name_regex,
        backend = {
          'binaries': installed_binaries,
          'debian': rule_debian
        },
        minidump_stackwalk = minidump_stackwalk,
      )
      if enable_crash_report:
        crash_test_bin = drake.cxx.Executable(
          'tests/functional/bin/crasher', [
            drake.node('tests/functional/bin/crasher.cc'),
            lib,
            crash_report_lib,
            cryptography_lib,
            elle_lib,
            reactor_lib,
            elle.boost.program_options_dynamic,
            elle.boost.filesystem_dynamic,
            elle.boost.regex_dynamic,
          ],
          cxx_toolkit,
          cxx_config)
      def functional_test(name, env = {}, binaries = []):
        t = {
          'name': name,
          'dependencies': [],
        }
        if env:
          t['env'] = env
        if binaries:
          t['dependencies'] = binaries
          t['paths'] = [str(x.path(True).dirname()) for x in binaries]
        return t
      utils = drake.nodes('tests/functional/utils.py',
                          'tests/common.py')
      if with_kvs:
        kvs_grpc = drake.copy(
          kvs.gen_py.targets(),
          'tests/functional/lib', strip_prefix = True)
      tests = list(
        map(lambda x: functional_test(x),
            [
              'cli-basics',
              'cli-backward-compatibility',
              'device_cli',
              'errors',
              #FIXME: 'flow',
              'main_cli',
              'network_cli',
              'passport-restrictions',
              # 'passport-sign-delegate',
              'passport_cli',
              'sanity',
              'silo-cli',
              'user_cli',
            ]))
      if not windows:
        # XXX: Hangs forever under wine, likely because of:
        # https://bugs.winehq.org/show_bug.cgi?id=38272
        tests.append(functional_test('key_value_store_cli'))
      doctor_configuration_test = functional_test(
        'doctor/configuration',
        env = {
          'MEMO_HOME_ROOT': drake.path_source('tests/functional/doctor/homes')
        })
      doctor_configuration_test['dependencies'] += drake.nodes(
        *list(map(lambda x: "tests/functional/doctor/results/%s" % x,
                  os.listdir(
                    str(drake.node(
                      'tests/functional/doctor/results/ok.script'
                    ).path().dirname())
                  ))))
      tests.append(doctor_configuration_test)
      if enable_crash_report:
        tests.append(functional_test('crash-report'))
      for t in tests:
        test = drake.node('tests/functional/%s' % t['name'])
        rule_functional_tests << test
        if enable_crash_report:
          test.dependencies_add([crash_test_bin])
        test.dependencies_add(installed_binaries)
        test.dependencies_add(beyond.package.nodes)
        test.dependencies_add(t.get('dependencies', []))
        test.dependency_add(cli)
        test.dependencies_add(utils)
        if with_kvs:
          test.dependencies_add(kvs_grpc)
        binaries_path = str(drake.path_build(installed_binaries[0].path(True).dirname(),
                                             absolute = True))
        extra_path = [binaries_path]
        extra_path += t.get('paths', [])
        if enable_crash_report:
          extra_path.append(str(drake.path_build(crash_test_bin.path(True).dirname(),
                                                 absolute = True)))
        extra_path.append(os.environ.get('PATH', ''))
        env = {
          'BIN_DIR': binaries_path,
          'BUILD_DIR': drake.path_build(),
          'OS': 'windows' if windows else 'unix',
          'PYTHONPATH': ':'.join([str(n) for n in
              [drake.path_build('beyond/lib/python%s' % elle.python3.version),
               drake.path_source('tests/functional'), # utils.py
               drake.path_source('tests'),            # common.py
               drake.path_build('tests/functional/lib')]]),
          'SOURCE_DIR': drake.path_source(),
          'TEST_MEMO_WITH_KVS': with_kvs,
        }
        env.update(t.get('env', {}))
        if windows:
          env['EXE_EXT'] = '.exe'
        runner = drake.Runner(
          exe = test,
          env = env,
          sources = utils,
        )
        rule_functional_check << runner.status
        runner.reporting = drake.Runner.Reporting.on_failure
      rule_tests << rule_functional_tests
      rule_check << rule_functional_check

  ## ----- ##
  ## Tests ##
  ## ----- ##

  global  cxx_config_tests
  cxx_config_tests = drake.cxx.Config(cxx_config)
  cxx_config_tests += elle.das.config
  cxx_config_tests.add_local_include_path('elle/tests')
  cxx_config_tests.lib_path_runtime('../lib')
  cxx_config_tests.lib_path_runtime('../../lib') # For consensus/async test.
  cxx_config_tests += elle.boost.config_test(link = False)
  cxx_config_tests += elle.boost.config_timer(link = False)
  cxx_config_tests.add_local_include_path('bin')
  cxx_config_tests.add_local_include_path('.')
  cxx_config_tests += grpc.grpc.cxx_config
  if enable_crash_report:
    cxx_config_tests.add_local_include_path('crash-report/src') # functional/bin/crasher
  tests_libdir = windows and 'tests' or 'lib'

  def copy_test_library(library, to = tests_libdir):
    return drake.copy(library, to, strip_prefix = True)

  cxx_config_tests.library_add(copy_test_library(elle.boost.test_dynamic))
  cxx_config_tests.library_add(copy_test_library(elle.boost.timer_dynamic))
  cxx_config_tests += elle.boost.config_system(link = False)
  cxx_config_tests.library_add(copy_test_library(elle.boost.system_dynamic))
  cxx_config_tests += elle.boost.config_filesystem(link = False)
  cxx_config_tests.library_add(copy_test_library(elle.boost.filesystem_dynamic))
  cxx_config_tests += elle.boost.config_program_options(
    link = False)
  cxx_config_tests.library_add(
    copy_test_library(elle.boost.program_options_dynamic))
  cxx_config_tests.library_add(copy_test_library(elle.boost.regex_dynamic))
  cxx_config_tests_no_boost_test = drake.cxx.Config(cxx_config_tests)
  lib_tests = lib
  libs_tests_consensus = [lib]
  grpc_lib_tests = grpc_libs

  if windows:
    cxx_config_tests.lib('shlwapi')
    cxx_config_tests.lib('ws2_32')
    cxx_config_tests.lib('gdi32')
    cxx_config_tests.lib('mswsock')
    cxx_config_tests.lib('dbghelp')
    cxx_config_tests.lib('iphlpapi')
    cxx_config_tests.lib('crypt32')
    cxx_config_tests.define('ELLE_TEST_NO_MEMFRY') # does not cross DLL boundaries

    cxx_config_tests_no_boost_test = drake.cxx.Config(cxx_config_tests)
    lib_tests = copy_test_library(lib)
    libs_tests_consensus += [copy_test_library(lib, tests_libdir + '/consensus')]
    dokan_lib_tests = copy_test_library(dokan_lib)
    dokan_lib_tests_consensus = copy_test_library(dokan_lib, tests_libdir + '/consensus')
    grpc_lib_tests = list(map(copy_test_library, grpc_lib_tests))

  tests_proto = drake.gRPC.CxxGen(drake.node('tests/grpc.proto'),
                                  grpc.grpc.protoc,
                                  grpc.grpc.grpc_cpp_plugin)
  tests_names = [
    # test_name               , deps                 , args = ['name-extension', tests-args...]
    # tests-args offer a means to run a binaries with different cli options,
    # and generate separated outputs.
    ('byzantine'              , []                   , None),
    ('consensus/async'        , libs_tests_consensus , None),
    ('consensus/cache'        , libs_tests_consensus , None),
    ('consensus/paxos'        , libs_tests_consensus , None),
    ('doughnut'               , []                   , None),
    ('faith'                  , []                   , None),
    ('grpc'                   , grpc_lib_tests       , None),
    ('overlay'                , []                   , ['kelips', '-t', 'kelips/*']),
    ('overlay'                , []                   , ['kouncil', '-t', 'kouncil/*']),
    ('rpc'                    , []                   , None),
    ('storage'                , [aws_lib]            , None),
  ]
  if enable_prometheus:
    tests_names.append(
      ('prometheus', [], None),
    )
  # The tests that do not use Boost.Test.
  non_boost_tests = ['backward-compatibility']
  tests_extra_libs = [elle_lib, cryptography_lib, reactor_lib, protocol_lib]
  if enable_prometheus:
    tests_extra_libs.append(prometheus_lib)

  if linux:
    cxx_config_tests.lib('dl')
  for test_name, deps, args in tests_names:
    that_test_libs = list(tests_extra_libs)
    if test_name == 'consensus/async':
      that_test_libs += libs_tests_consensus
    if windows:
      if test_name == 'consensus/async':
        that_test_libs += [dokan_lib_tests_consensus]
      else:
        that_test_libs += [dokan_lib_tests]
    if test_name == 'grpc':
      that_test_libs += tests_proto.targets()
      if windows:
        # Why ?
        that_test_libs += grpc.gen_vs_w_named.targets()
    test = drake.cxx.Executable(
      'tests/%s' % test_name,
      [
        drake.node('tests/%s.cc' % test_name),
      ] + that_test_libs + [lib_tests] + deps,
      cxx_toolkit,
      cxx_config_tests_no_boost_test if test_name in non_boost_tests else cxx_config_tests)
    rule_tests << test
    env = {
      'BUILD_DIR': drake.path_build(),
      'BOOST_TEST_COLOR_OUTPUT': '1',
      'BOOST_TEST_LOG_LEVEL': 'all',
      'BOOST_TEST_LOG_SINK': 'stderr',  # Keep our logs, and Boost's, together.
      'SOURCE_DIR': drake.path_source(),
    }
    #  _____ _____  ____  __ _____
    # |  ___|_ _\ \/ /  \/  | ____|
    # | |_   | | \  /| |\/| |  _|
    # |  _|  | | /  \| |  | | |___
    # |_|   |___/_/\_\_|  |_|_____|
    #
    # Really, really do run these tests on valgrind !!!
    if args:
      test_name = '{}-{}'.format(test_name, args[0])
      args = args[1:]
    if valgrind_tests and test_name not in ['filesystem']:
      runner = drake.valgrind.ValgrindRunner(name = test_name,
                                             exe = test,
                                             args = args,
                                             valgrind = elle.valgrind,
                                             env = env)
    else:
      runner = drake.Runner(name = test_name,
                            exe = test,
                            args = args,
                            env = env)
    runner.reporting = drake.Runner.Reporting.on_failure
    rule_check << runner.status

  ## ------- ##
  ## Bench.  ##
  ## ------- ##
  rule_bench = drake.Rule('bench')

# Local Variables:
# mode: python
# End: