path: root/Taskfile.yaml

# https://taskfile.dev

#Called by the vnbuild system to produce builds for my website
#https://www.vaughnnugent.com/resources/software

#This taskfile performs the build operations for a module, it handles
#git code updates, msbuild on solutions, and sleet NuGet feed pushes.

#this file must be in the same directory as the solution file

#NOTES: Since CI project is pulled from the module root, MODULE_DIR is used instead of PROJECT_DIR

version: '3'

vars:

  _RMDIR: '{{ if eq OS "windows" }}powershell rm -Recurse -Force{{else}}rm -rf{{end}}'
  _MKDIR: '{{ if eq OS "windows" }}powershell mkdir -Force{{else}}mkdir -p{{end}}'
  BINARY_DIR: '{{ .BINARY_DIR | default "bin" }}'

  CMAKE_BUILD_DIR: 'build/{{ OS }}'
  TEST_EXE_NAME: 'nctest'
  CI_BUILD_CONFIG: '{{ .CI_BUILD_CONFIG | default "Release" }}'

  MBEDTLS_VERSION: '3.6.2'
  MBEDTLS_ARCHIVE_SHA: '' 

tasks:

  default:
    desc: "Build the library for your system"
    cmds:
     - task: cmake-build
       vars: { CMAKE_TEST_STATUS: 'OFF', BUILD_CONFIG: 'Release' }

  build-debug:
    desc: "Build libraries and test executable in debug mode"
    summary: |
      Runs the CMake configure and compile steps to build the library 
      and test executable in debug mode.
    cmds:
     - task: cmake-build
       vars: { CMAKE_TEST_STATUS: 'ON', BUILD_CONFIG: 'Debug' }

  #available to users and vnbuild runner
  test:
    desc: "Builds a local copy of the library in a debug configuration, then runs the test executable"
    cmds:
     - task: build-debug
 
     - task: cmake-test
       vars: { CMAKE_BUILD_DIR: '{{ .CMAKE_BUILD_DIR }}' }

  install:
    desc: "Uses cmake to install the library on your system"
    cmds:
     - cmd: echo "Installing noscrypt globally"
       silent: true
     - task: cmake-install
   
  #Test executable and library must be built for tests to run
  memcheck:
    desc: 'Runs Valgrind memcheck in debug mode against the nctest executable (Linux only)'
    summary: |
      Runs Valgrind memcheck in debug mode against the nctest executable. 
      This task is only available on Linux platforms with Valgrind and the 
      Memcheck tool is installed. You must build the test executable in debug
      mode before running this task.
    platforms:
      - linux 
    preconditions:
      - which valgrind
    cmds:
     - cmd: echo "Running valgrind memory check on test executable"
       silent: true
     - cmd: 
         valgrind 
         --tool=memcheck
         --leak-check=full 
         --show-leak-kinds=all 
         --track-origins=yes 
         {{ .CMAKE_BUILD_DIR }}/{{ .TEST_EXE_NAME }}

  clean:
    desc: "Cleans the build and artifact directories"
    ignore_error: true
    cmds:
    - for: [ bin/, build/ ]
      cmd: '{{ ._RMDIR }} "{{ .ITEM }}"'

#################################
#
#       INTERNAL TASKS
#
#################################

  cmake-configue: 
    internal: true
    requires: { CMAKE_BUILD_DIR, BUILD_CONFIG, CMAKE_TEST_STATUS }
    cmds:
     - cmd: cmake
        -S . 
        -B{{ .CMAKE_BUILD_DIR }} 
        -DCMAKE_BUILD_TYPE={{ .BUILD_CONFIG }} 
        -DNC_BUILD_TESTS={{ .CMAKE_TEST_STATUS }}
        {{ .CLI_ARGS }} 
        {{ .CMAKE_CONFIG_ARGS }}
        

  #perfoms CMake compile step
  cmake-compile:    
    internal: true
    requires: { CMAKE_BUILD_DIR, BUILD_CONFIG }
    cmds:
     - cmd: cmake 
        --build {{ .CMAKE_BUILD_DIR }} 
        --config {{ .BUILD_CONFIG }}
  
  #runs the configure and compile cmake steps
  cmake-build:
    internal: true
    requires: { CMAKE_BUILD_DIR, BUILD_CONFIG, CMAKE_TEST_STATUS }
    cmds:
     - task: cmake-configue
       vars: 
         CMAKE_BUILD_DIR: '{{ .CMAKE_BUILD_DIR }}'
         BUILD_CONFIG: '{{ .BUILD_CONFIG }}'
         CMAKE_TEST_STATUS: '{{ .CMAKE_TEST_STATUS }}'
         CMAKE_CONFIG_ARGS: '{{ .CMAKE_CONFIG_ARGS }}'
     
     - task: cmake-compile
       vars: 
         CMAKE_BUILD_DIR: '{{ .CMAKE_BUILD_DIR }}'
         BUILD_CONFIG: '{{ .BUILD_CONFIG }}'

  #runs the cmake install step
  cmake-install:
    internal: true
    requires: { CMAKE_BUILD_DIR }
    cmds:
     - cmd: cmake --install {{ .CMAKE_BUILD_DIR }} {{ .CLI_ARGS }}
  
  cmake-test:
    internal: true
    requires: { CMAKE_BUILD_DIR }
    cmds:
     - cmd: cd {{ .CMAKE_BUILD_DIR }} && ctest -C Debug --verbose --output-on-failure

  mbedtls-download:
    internal: true
    requires: { CMAKE_BUILD_DIR, MBEDTLS_VERSION }
    vars:
      MBEDTLS_DOWNLOAD_URL: 'https://github.com/Mbed-TLS/mbedtls/releases/download/mbedtls-{{ .MBEDTLS_VERSION }}/mbedtls-{{ .MBEDTLS_VERSION }}.tar.bz2'
      MBEDTLS_DOWNLOAD_DIR: '{{ .CMAKE_BUILD_DIR }}/_deps'
      MBEDTLS_SRC_DIR: '{{ .MBEDTLS_DOWNLOAD_DIR }}/mbedtls-{{ .MBEDTLS_VERSION }}'
    cmds:
     #ensure directory is created
     - cmd: '{{ ._MKDIR }} "{{ .MBEDTLS_SRC_DIR }}"'
      
     #download mbedtls archive
     - cmd: curl{{ exeExt }} -L '{{ .MBEDTLS_DOWNLOAD_URL }}' -o '{{ .MBEDTLS_DOWNLOAD_DIR }}/mbedtls.tar.bz2'
 
     #extract the archive using bz2 (linux only)
     - cmd: '{{ if eq OS "windows" }}wsl{{ end }} tar -xjf "{{ .MBEDTLS_DOWNLOAD_DIR }}/mbedtls.tar.bz2" -C "{{ .MBEDTLS_DOWNLOAD_DIR }}"'
  
  mbedtls-configure:
    internal: true
    requires: { CMAKE_BUILD_DIR, MBEDTLS_VERSION }
    vars:
      MBEDTLS_SRC_DIR: '{{ .CMAKE_BUILD_DIR }}/_deps/mbedtls-{{ .MBEDTLS_VERSION }}'
      MBEDTLS_BUILD_DIR: '{{ .CMAKE_BUILD_DIR }}/_deps/mbedtls-build'
      MBEDTLS_CONFIG_FILE: '{{ .USER_WORKING_DIR }}/vendor/mbedtls/mbedtls_noscrypt_config.h'
    cmds:
     #clear build dir before re-configuring
     - cmd: '{{ .RMDIR }} "{{ .MBEDTLS_BUILD_DIR }}"'
       ignore_error: true

     - cmd: cmake 
        -S '{{ .MBEDTLS_SRC_DIR }}' 
        -B '{{ .MBEDTLS_BUILD_DIR }}' 
        -DCMAKE_BUILD_TYPE=Release 
        -DENABLE_PROGRAMS=OFF 
        -DENABLE_TESTING=OFF
        -DBUILD_SHARED_LIBS=OFF
        -DUSE_SHARED_MBEDTLS_LIBRARY=OFF
        -DUSE_STATIC_MBEDTLS_LIBRARY=ON
        -DDISABLE_PACKAGE_CONFIG_AND_INSTALL=ON
        -DMBEDTLS_CONFIG_FILE='{{ .MBEDTLS_CONFIG_FILE }}'

  mbedtls-compile:
    internal: true
    requires: { CMAKE_BUILD_DIR }
    vars:
      MBEDTLS_BUILD_DIR: '{{ .CMAKE_BUILD_DIR }}/_deps/mbedtls-build'
    cmds:
     - cmd: cmake --build '{{ .MBEDTLS_BUILD_DIR }}' --config Release
    
  mbedtls-build:
    internal: true
    desc: "Downloads, configures, and compiles mbedtls"
    requires: { CMAKE_BUILD_DIR }
    cmds:
     - task: mbedtls-download
       vars: { CMAKE_BUILD_DIR: '{{ .CMAKE_BUILD_DIR }}' }
     - task: mbedtls-configure
       vars: { CMAKE_BUILD_DIR: '{{ .CMAKE_BUILD_DIR }}' }
     - task: mbedtls-compile
       vars: { CMAKE_BUILD_DIR: '{{ .CMAKE_BUILD_DIR }}' }

#################################
#       
#       CI TASKS
#
#################################

  # runs the cmake setups to configure the mbedtls library build for testing
  ci-configure-mbedtls:
    internal: false
    requires: { CMAKE_BUILD_DIR }
    cmds:
     - task: mbedtls-build
       vars: { CMAKE_BUILD_DIR: '{{ .CMAKE_BUILD_DIR }}' }

     - task: cmake-build
       vars: 
         CMAKE_TEST_STATUS: 'ON'
         BUILD_CONFIG: 'Debug'
         CMAKE_BUILD_DIR: '{{ .CMAKE_BUILD_DIR }}'
         CMAKE_CONFIG_ARGS: '
          -DNC_ENABLE_UTILS=ON
          -DCRYPTO_LIB=mbedtls
          -DCRYPTO_LIB_DIR={{ .CMAKE_BUILD_DIR }}/_deps/mbedtls-build'

  # runs the cmake setups to configure the default library build for testing
  ci-configure-default:
    internal: true
    requires: { CMAKE_BUILD_DIR }
    cmds:
     - task: cmake-build
       vars: 
         CMAKE_TEST_STATUS: 'ON'
         BUILD_CONFIG: 'Debug'
         CMAKE_BUILD_DIR: '{{ .CMAKE_BUILD_DIR }}'
         CMAKE_CONFIG_ARGS: '-DNC_ENABLE_UTILS=ON'

  # runs cmake testing and memcheck on the mbedtls build
  ci-test-mbedtls:
    internal: false
    requires: { CMAKE_BUILD_DIR }
    cmds:
     - task: cmake-test
       vars: { CMAKE_BUILD_DIR: '{{ .CMAKE_BUILD_DIR }}' }

     #runs memcheck if the platform supports it
     - task: memcheck
       vars: { CMAKE_BUILD_DIR: '{{ .CMAKE_BUILD_DIR }}' }

  # runs cmake testing and memcheck on the default build
  ci-test-default:
    internal: true
    requires: { CMAKE_BUILD_DIR }
    cmds:

     - task: cmake-test
       vars: { CMAKE_BUILD_DIR: '{{ .CMAKE_BUILD_DIR }}' }

     #runs memcheck if the platform supports it
     - task: memcheck
       vars: { CMAKE_BUILD_DIR: '{{ .CMAKE_BUILD_DIR }}' }

  # called by Module.taskfile to run tests
  ci-test:
    vars:
      MBEDTLS_BUILD_DIR: '{{ .CMAKE_BUILD_DIR }}/test/mbedtls'
      DEFAULT_BUILD_DIR: '{{ .CMAKE_BUILD_DIR }}/test/default'
    deps:
      - task: ci-configure-default
        vars: { CMAKE_BUILD_DIR: '{{ .DEFAULT_BUILD_DIR }}' }
      - task: ci-configure-mbedtls
        vars: { CMAKE_BUILD_DIR: '{{ .MBEDTLS_BUILD_DIR }}' }    
    cmds:
     #cleanup build directories after testing
     - defer: '{{ ._RMDIR }} "{{ .CMAKE_BUILD_DIR }}/test"'

     - task: ci-test-default
       vars: { CMAKE_BUILD_DIR: '{{ .DEFAULT_BUILD_DIR }}'}#

     - task: ci-test-mbedtls
       vars: { CMAKE_BUILD_DIR: '{{ .MBEDTLS_BUILD_DIR }}'}

  ci-pack-source:
    internal: true
    desc: "Packs up the project source code and creates a tarball in the builds binary directory"
    vars:
      TARGET_SOURCE: '{{ .PROJECT_DIR }}/{{ .BINARY_DIR }}/{{ .PROJECT_NAME }}-src.tgz'
      SOURCE_FILES: 
        CMakeLists.txt
        Taskfile.yaml
        src
        include
        license
        tests
        vendor
        readme.md
        CMakePresets.json

    cmds:
      #tar up the source
     - cmd: tar -czf "{{ .TARGET_SOURCE }}" {{ .SOURCE_FILES | join " " }}  

  ci-build-win_x64:
    internal: true
    requires: { CMAKE_BUILD_DIR, BINARY_DIR, PROJECT_DIR, CI_BUILD_CONFIG, PROJECT_NAME }
    platforms: [ windows ]
    vars:
      TARGET: '{{ .PROJECT_DIR }}/{{ .BINARY_DIR }}/msvc-x64-{{ .CI_BUILD_CONFIG }}-{{ .PROJECT_NAME }}.tgz'
      BUILD_DIR: 'build/win-x64'

      TAR_FILES: "
        {{ .PROJECT_NAME }}.dll 
        {{ .PROJECT_NAME }}.lib
        {{ .PROJECT_NAME }}_static.lib
        license.txt"
    
    cmds:
    #remove deps dir to avoid conflicts with vnbuild
     - defer: '{{ ._RMDIR }} "{{ .BUILD_DIR }}/_deps"'

     #run configure and compile commands 
     - task: cmake-build
       vars: 
         CMAKE_BUILD_DIR: '{{ .BUILD_DIR }}'
         BUILD_CONFIG: '{{ .CI_BUILD_CONFIG }}'
         CMAKE_TEST_STATUS: 'OFF'
         CMAKE_CONFIG_ARGS: '-G "Visual Studio 17 2022" -A x64 -DNC_ENABLE_UTILS=ON'

    #copy license to build dir
     - cmd: powershell cp license '{{ .BUILD_DIR }}/{{ .CI_BUILD_CONFIG }}/license.txt'

    #tar up the binaries
     - cmd: cd {{ .BUILD_DIR }}/{{ .CI_BUILD_CONFIG }} &&  tar -czf "{{ .TARGET }}" {{ .TAR_FILES }}

 #called by build pipeline to build module
  build:
    cmds:
     - cmd: echo "building project {{ .PROJECT_NAME }}" 
     - cmd: '{{ ._MKDIR }} {{ .BINARY_DIR }}'
  
     #build windows x64
     - task: ci-build-win_x64

     #pack source
     - task: ci-pack-source

#################################
#
#       DEV TASKS
#
#################################

  dev-test:
    desc: "Re-runs compilation phase and test executable"
    cmds:
     - task: cmake-compile
       vars: { BUILD_CONFIG: 'Debug' }

     - task: cmake-test
       vars: { CMAKE_BUILD_DIR: '{{ .CMAKE_BUILD_DIR }}' }

     - task: memcheck

  dev:
    desc: "Runs local development tests and watches for changes"
    summary: |
      Watches for changes to source and config files, recompiles, and runs tests
      automatically when changes are detected. 
    watch: true
    sources:
      - include/*
      - src/*
      - src/*/* 
      - tests/*
      - CMakelists.txt
      - vendor/* 
    cmds:
     - task: dev-test

  dev-gdb-test:
    platforms: [ linux ]
    desc: "Starts a new gdb session on the test executable"
    summary: |
      (Linux only) Starts a new gdb session on the test executable.
      Use the 'run' command to start the test executable. 
    interactive: true
    cmds:
     - task: cmake-compile
       vars: { BUILD_CONFIG: 'Debug' }

     - cmd: gdb '{{ .CMAKE_BUILD_DIR }}/{{ .TEST_EXE_NAME }}'
  
  dev-update-deps:
     desc: "Updates vendored projects files (headers mostly) from their source repositories to the configured version"
     cmds:
      - defer: '{{ ._RMDIR }} .update/'
  
      #must run serially since git does not support mutliple instances
      - task: dev-update-monocypher
      - task: dev-update-mbedtls-headers
      - task: dev-update-openssl-headers
      - task: dev-set-secp256-headers

  dev-update-monocypher:
    vars:
      MC_GIT_URL: 'https://github.com/LoupVaillant/Monocypher'
      MC_GIT_BRANCH: 'master'       #NOTE: Always update to the latest master branch, then verify changes manually
      MC_DIR: 'vendor/monocypher'
      TMP_DIR: '.update/mc'
    cmds:
     - cmd: '{{ ._MKDIR }} "{{ .TMP_DIR }}"'
       ignore_error: true
     
     - cmd: git clone --depth 1 --branch {{ .MC_GIT_BRANCH }} {{ .MC_GIT_URL }} '{{ .TMP_DIR }}' 

     - for: [ 'src/monocypher.h', 'src/monocypher.c' ]
       cmd: powershell cp '{{ .TMP_DIR }}/{{ .ITEM }}' '{{ .MC_DIR }}'

  dev-update-mbedtls-headers:
    vars:
      MBEDTLS_GIT_URL: 'https://github.com/Mbed-TLS/mbedtls'
      MBEDTLS_GIT_BRANCH: 'v{{ .MBEDTLS_VERSION }}'
      MBEDTLS_DIR: 'vendor/mbedtls'
      TMP_DIR: '.update/mbedtls'
    cmds:
     - cmd: '{{ ._MKDIR }} "{{ .TMP_DIR }}"'
       ignore_error: true

     - cmd: git clone --depth 1 --branch {{ .MBEDTLS_GIT_BRANCH }} {{ .MBEDTLS_GIT_URL }} '{{ .TMP_DIR }}' 

     - for: [ 'include/mbedtls' ]
       cmd: powershell cp -Recurse -Force '{{ .TMP_DIR }}/{{ .ITEM }}' '{{ .MBEDTLS_DIR }}'

  dev-update-openssl-headers:
    vars:
      OPENSSL_GIT_URL: 'https://github.com/openssl/openssl'
      OPENSSL_GIT_BRANCH: 'openssl-3.4.0'
      OPENSSL_DIR: 'vendor/openssl'
      TMP_DIR: '.update/openssl'
    cmds:
     - cmd: '{{ ._MKDIR }} "{{ .TMP_DIR }}"'
       ignore_error: true
     
     - cmd: git clone --depth 1 --branch {{ .OPENSSL_GIT_BRANCH }} {{ .OPENSSL_GIT_URL }} '{{ .TMP_DIR }}' 
     
     - for: [ 'include/openssl/*' ]
       cmd: powershell cp -Recurse -Force '{{ .TMP_DIR }}/{{ .ITEM }}' '{{ .OPENSSL_DIR }}'

  dev-set-secp256-headers:
    vars:
      SECP256_GIT_URL: 'https://github.com/bitcoin-core/secp256k1'
      SECP256_GIT_BRANCH: 'v0.6.0'
      SECP256_DIR: 'vendor/secp256k1'
      TMP_DIR: '.update/secp256k1'
    cmds:
     - cmd: '{{ ._MKDIR }} "{{ .TMP_DIR }}"'
       ignore_error: true
     
     - cmd: git clone --depth 1 --branch {{ .SECP256_GIT_BRANCH }} {{ .SECP256_GIT_URL }} '{{ .TMP_DIR }}' 
     
     - for: [ 'include/*' ]
       cmd: powershell cp -Recurse -Force '{{ .TMP_DIR }}/{{ .ITEM }}' '{{ .SECP256_DIR }}'