meson.build

project('donet', 'rust',
          version: '0.1.0',
    meson_version: '>= 1.1.0',
  default_options: [ 'warning_level=2', 'werror=false', ],
)

# Check MinGW or equivalent for Windows build machines
# See: https://github.com/mesonbuild/meson/issues/8776
if build_machine.system() == 'windows'
  assert(
    find_program('bash', required: false).found(),
    'Windows detected, but no GNU core utils found.\n\t' +
    'A MinGW environment, or equivalent, is required to build Donet.'
  )
endif

git_bin = find_program('git', required: true)
cargo_bin  = find_program('cargo', required: true)
find_program('ninja', required: true)
sphinx_bin = find_program('sphinx-build', required: false)
date_bin = find_program('date', required: true)

daemon_bin = meson.project_name() + 'd'
vcs_tag = run_command(git_bin, 'rev-parse', 'HEAD', check: false).stdout().strip()
build_timestamp = run_command(date_bin, '--rfc-email', check: false).stdout().strip()

# The Git branch name is the version name for sphinx docs in the live site
git_branch = get_option('ci_branch')

if git_branch == ''
  git_branch = run_command(git_bin, 'branch', '--show-current', check: true).stdout().strip()
endif

# Used in configuring Sphinx documentation to link sources to the repo.
sphinx_version = '7.4'
sphinx_release = 'master' # Full version tag (major.minor.patch)
doc_versions = '[["master", "/master"]]' # Python nested list
git_host = 'forgejo'
git_host_user = 'donet'
git_host_repo = 'donet'
git_url = 'https://git.maxrdz.com/' + git_host_user + '/' + git_host_repo
donet_website_url = 'https://www.donet-server.org'
libdonet_website_url = 'https://docs.donet-server.org/donet_core'
sphinx_website_url = 'https://docs.donet-server.org'

# Cargo build options and environment variables
cargo_opts = [ '--manifest-path', meson.project_source_root() / 'Cargo.toml' ]
cargo_opts += [ '--target-dir', meson.project_build_root()  / 'target' ]

cargo_env = environment()
cargo_env.set('CARGO_HOME', meson.project_build_root() / 'cargo-home')

feature_flags = []

if get_option('profile') == 'release'
  cargo_opts += [ '--release' ]
  rust_target = 'release'

  message('Building for Release.')
else
  rust_target = 'debug'
  feature_flags += ['tokio_debugging']

  # Needed for Tokio async runtime instrumentation
  cargo_env.set('RUSTFLAGS', '--cfg tokio_unstable')

  message('Building for Debug.')
  endif

if get_option('build_wcp')
  cargo_opts += ['--package', 'donet-wcp']

  # override output bin to `donetwcp`
  daemon_bin = 'donetwcp'

  message('Building Donet WCP application.')
else
  if get_option('dockerized')
    feature_flags += ['dockerized']
  endif

  if get_option('build_client_agent')
    feature_flags += [ 'client-agent' ]
    message('Building the Client Agent.')
  endif

  if get_option('build_message_director')
    feature_flags += [ 'message-director' ]
    message('Building the Message Director.')
  endif

  if get_option('build_state_server')
    feature_flags += [ 'state-server' ]
    message('Building the State Server.')
  endif

  if get_option('build_database_server')
    feature_flags += [ 'database-server' ]
    message('Building the Database Server.')
  endif

  if get_option('build_dbss')
    feature_flags += [ 'dbss' ]
    message('Building the DBSS.')
  endif

  if get_option('build_event_logger')
    feature_flags += [ 'event-logger' ]
    message('Building the Event Logger.')
  endif
endif

# Convert FF list to argument string for --features option
cargo_ff_arg = ''
first_flag = false
foreach ff : feature_flags
  if first_flag == false
    cargo_ff_arg += ff
    first_flag = true
  else
    cargo_ff_arg += ',' + ff
  endif
endforeach

if feature_flags.length() > 0
  cargo_opts += [ '--no-default-features', '--features', cargo_ff_arg ]
else
  if get_option('build_wcp')
    message('Building WCP with default feature flags..')
  else
    message('Building all default Donet services.')
  endif
endif

subdir('donet-daemon')
subdir('docs')

run_target(
  'update',
  env: cargo_env,
  command: [ cargo_bin, 'update', '--verbose' ]
)

cargo_build = custom_target(
  'cargo-build',
  build_by_default: true,
  build_always_stale: true,
  output: 'cargo_build', # See 'outdir' custom target
  console: true,
  env: cargo_env,
  command: [
    cargo_bin, 'build', cargo_opts,
  ]
)

# Replace below with `--out-dir` cargo option once stable.
# Issue: https://github.com/rust-lang/cargo/issues/6790
custom_target(
  'outdir',
  build_by_default: true,
  build_always_stale: true,
  output: meson.project_name(),
  console: true,
  command: [
    'cp', 'target' / rust_target / daemon_bin, '@BUILD_ROOT@',
  ],
  depends: cargo_build
)

cargo_doc = custom_target(
  'cargo-doc',
  build_by_default: false,
  build_always_stale: true,
  output: 'doc',
  console: true,
  env: cargo_env,
  command: [
    cargo_bin, 'doc', cargo_opts, '--lib', '--no-deps',
    '--document-private-items', '--config',
    'build.rustdocflags="--default-theme=ayu"'
  ],
)

clippy = custom_target(
  'clippy',
  env: cargo_env,
  output: 'clippy',
  command: [
    cargo_bin, 'clippy', '--color=always', cargo_opts,
  ],
)

run_target(
  'linting',
  env: cargo_env,
  command: [
    cargo_bin, 'fmt', '--all', '--', '--color=always', '--check',
  ],
  depends: clippy,
)

cargo_deny = custom_target(
  'cargo-deny',
  env: cargo_env,
  output: 'cargo-deny',
  command: [
    cargo_bin, 'install', 'cargo-deny', '--locked',
  ],
)

run_target(
  'deny',
  env: cargo_env,
  command: [
    cargo_bin, 'deny', '--manifest-path',
    meson.project_source_root() / 'Cargo.toml', 'check'
  ],
  depends: cargo_deny
)

cargo_tarpaulin = custom_target(
  'cargo-tarpaulin',
  output: 'cargo-tarpaulin',
  env: cargo_env,
  command: [
    cargo_bin, 'install', 'cargo-tarpaulin',
  ]
)

# Runs cargo-tarpaulin to create code coverage JSON and XML files,
# which is used by the Forgejo CI/CD job to upload to codecov.io.
run_target(
  'code-coverage',
  env: cargo_env,
  command: [
    cargo_bin, 'tarpaulin',
    '--force-clean', '--all',
    '--engine', 'llvm', # use LLVM instead of ptrace so we dont need to disable ASLR on CI/CD
    '--exclude-files', 'build/*',
    '--exclude-files', 'builddebug/*',
    '--exclude-files', 'buildwcp/*',
    '--exclude-files', 'buildwcpdebug/*',
    '--out', 'xml',
    '--output-dir', meson.project_build_root() / 'target' / 'tarpaulin',
    cargo_opts
  ],
  depends: cargo_tarpaulin,
)

# Build unit tests without running. This outputs the binary
# for the unit tests in the target directory, which can then
# be debugged using GDB or an equivalent.
run_target(
  'build-tests',
  env: cargo_env,
  command: [
    cargo_bin, 'test', '--no-run', cargo_opts,
  ]
)

# Wrapper for `meson test`, but adds the `--verbose`
# flag so it actually outputs `cargo test` stdout/stderr.
run_target(
  'tests',
  command: [ 'meson', 'test', '--verbose' ],
)

test(
  'cargo-test',
  cargo_bin,
  env: cargo_env,
  args: [
    'test', '--color=always', '--workspace', '--exclude', 'donet-wcp',
    cargo_opts,
  ],
  is_parallel: false,
  timeout: 1800,
)

message('Setting up Git pre-commit hook..')
run_command('cp', '-f', 'build-aux/git/pre-commit.hook', '.git/hooks/pre-commit', check: false)
run_command('cp', '-f', 'build-aux/git/pre-push.hook', '.git/hooks/pre-push', check: false)

meson.add_dist_script(
  'build-aux/meson/dist-vendor.sh',
  meson.project_build_root() / 'meson-dist' / meson.project_name() + '-' + meson.project_version(),
  meson.project_source_root()
)